> For the complete documentation index, see [llms.txt](https://overleaf-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://overleaf-pro.ayaka.space/latex/id/artikel-mendalam/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Bagaimana \expandafter bekerja: Dari prinsip dasar hingga menjelajahi kode sumber TeX [Bagian 1](/latex/id/artikel-mendalam/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Bagian 2](/latex/id/artikel-mendalam/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Bagian 3](/latex/id/artikel-mendalam/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Bagian 4](/latex/id/artikel-mendalam/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Bagian 5](/latex/id/artikel-mendalam/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Bagian 6](/latex/id/artikel-mendalam/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Pendahuluan Sekarang kita telah membahas topik latar belakang yang diperlukan untuk eksplorasi menyeluruh tentang `\expandafter`: * dasar-dasar token TeX dan bagaimana token tersebut dihitung; * prinsip-prinsip di balik proses perluasan TeX; * penggunaan/pembuatan daftar token sementara oleh TeX selama pemrosesan dokumen; * bagaimana TeX menggunakan dan “mengutak-atik” beberapa sumber input sekaligus (termasuk daftar token sementara). Dalam artikel ini kita akan menyatukan topik/konsep ini untuk menjelaskan mekanisme di balik `\expandafter` perintah TeX: singkatnya, cara kerjanya. ## Dan jadi, untuk \expandafter Gagasan di balik `\expandafter` adalah memaksa perluasan suatu perintah (token) sebelum TeX biasanya melakukannya. Dengan dua token, $$\mathrm{T\_1}$$ dan $$\mathrm{T\_2}$$ aksi dari `\expandafter` $$\mathrm{T\_1T\_2}$$ mengakibatkan TeX memproses $$\mathrm{T\_1}\text{<}$$perluasan dari $$\mathrm{T\_2}\text{>}$$, di mana $$\text{<}\dots\text{>}$$ menunjukkan sebuah daftar token. TeX memperluas $$\mathrm{T\_2}$$ lebih awal sehingga token $$\mathrm{T\_1}$$ (misalnya, primitif atau makro) dapat melihat, atau dapat bertindak atas, token-token yang dihasilkan dari perluasan $$\mathrm{T\_2}$$. Jika token $$\mathrm{T\_2}$$ mewakili item yang tidak dapat diperluas seperti karakter nonaktif atau sebagian besar primitif, aksi dari `\expandafter` tidak mengubah apa pun: TeX akan terus memproses token-token $$\mathrm{T\_1T\_2}$$ dengan cara normal. ### Pengantar penggunaan \expandafter Jika Anda belum pernah menggunakan `\expandafter`, berikut contoh penggunaannya dengan primitif `\uppercase{...}`. Misalkan kita ingin menata nama `.tex` file input utama kita tetapi dengan huruf kapital. Kita mungkin mengetahui perintah primitif TeX berikut: * `\uppercase`: sesuai namanya, mengubah token karakter menjadi padanan huruf kapitalnya (jika ada); * `\jobname`: seperti yang telah kita lihat, berkembang untuk memberikan nama dari `.tex` . Dengan asumsi file TeX kita bernama `mycode.tex` kita secara wajar mungkin mengharapkan `\uppercase{\jobname}` untuk menata `MYCODE`. Tapi tidak, ia menata `mycode` sebagai huruf kecil. Apa yang “salah”? Jika kita menulis penggunaan umum dari `\uppercase` sebagai ``` \uppercase{} ``` kita dapat mengatakan bahwa `\uppercase` menelusuri `` dan hanya akan beroperasi (mengubah kapitalisasi) pada *token karakter* yang dideteksinya di dalam ``: semua token non-karakter *diabaikan* karena `\uppercase` tidak akan “melihat ke dalam” (memperluas) token non-karakter untuk melihat apa yang dikandung atau diwakilinya. Karena sebuah token hanyalah nilai integer, semua `\uppercase` yang harus dilakukan adalah menelusuri daftar token untuk memeriksa apakah nilai numerik setiap token dalam `` berada dalam rentang nilai yang menunjukkan token karakter. Kebetulan, `\uppercase` juga akan *mengubah kapitalisasi karakter aktif* untuk membuat karakter aktif berhuruf kapital yang, karena masih aktif, juga harus telah didefinisikan; jika tidak, TeX akan menghasilkan kesalahan: `Rangkaian kontrol tak terdefinisi`, tapi kita menyimpang... Sebagai contoh, bahkan jika kita mendefinisikan sebuah makro yang hanya berupa teks ``` \def\foo{some lower-case text} ``` maka `\uppercase{\foo}` tetap menata `teks huruf kecil` dan bukan `TEKS HURUF KECIL SEMUA` seperti yang kita harapkan, hanya karena aksi dari `\uppercase` tidak mencoba menentukan apa yang `\foo` mewakili: ia melihat `\foo` sebagai token perintah dan mengabaikannya, seperti yang dilakukannya dengan `\jobname`. ### Bagaimana kita bisa memperbaikinya? \expandafter menyelamatkan Untuk menata versi huruf kapital dari nama file, kita perlu memodifikasi `\uppercase{\jobname}` dengan memaksa TeX mengganti `\jobname` dengan hasil perluasannya (sebuah urutan token karakter) *sebelum* `\uppercase` mulai bekerja. Sekali lagi, perluasan digunakan untuk menghapus `\jobname` token (perintah) dan menggantinya dengan hasil perluasannya (daftar token yang berisi token karakter). Jadi, jika kita menulis ``` \uppercase\expandafter{\jobname} ``` maka itu berhasil: `MYCODE` akan ditata. Yang terjadi adalah TeX mulai memproses `\uppercase` dan segera memeriksa karakter kurung kurawal pembuka wajib (`{`{ `\expandafter` perintah yang menyebabkan ia untuk sementara “mengalihkan perhatiannya” untuk memproses `\expandafter{\jobname}`. Jika kita membandingkan `\expandafter` $$\mathrm{T\_1T\_2}$$ dengan contoh kita `\expandafter{\jobname}` kita dapat melihat * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Di mana `{`token dan `\jobname`token merujuk pada nilai token yang dihitung oleh TeX—notasi subskrip token digunakan untuk mengingatkan kita bahwa TeX bekerja di dunia token integer. Menulis `\uppercase\expandafter{\jobname}` berhasil karena, secara garis besar (rincian menyusul), `\expandafter` menyebabkan TeX melakukan tugas-tugas berikut: 1. membaca dan menyimpan pembuka `{`token; 2. membaca token berikutnya: `\jobname`token. TeX mengenali bahwa `\jobname`token mewakili perintah yang dapat diperluas dan memperluasnya. `\jobname`token digantikan dengan hasil perluasannya—serangkaian token karakter; 3. setelah memperluas `\jobname` perintah, TeX memasukkan `{`$$\_\mathrm{token}$$ “kembali ke input” dan menggunakan daftar token yang muncul dari perluasan `\jobname` agar TeX akan membaca `\uppercase{`token``daftar token (karakter)`}`, dan ini menghasilkan hasil yang kita inginkan. Diagram berikut menunjukkan bagaimana TeX memproses `\uppercase\expandafter{\jobname}`—bacalah grafik dari bawah dan bergerak ke atas untuk mengikuti alur proses. ![Cara kerja \expandafter](/files/2a22794c62c05195a0c9f2473566d8dfc46f009b) Catatan berikut menjelaskan berbagai tahap pemrosesan. 1. TeX mulai memproses `\uppercase` dan memeriksa karakter kurung kurawal pembuka wajib (`{`) tetapi mendeteksi sebuah `\expandafter` perintah. 2. Jika kita membandingkan `\expandafter` $$\mathrm{T\_1T\_2}$$ pada input kita berupa `\expandafter{\jobname}` kita dapat melihat $$\mathrm{T\_1} =$$`{`token dan $$\mathrm{T\_2} =$$`\jobname`token. Perhatikan bahwa di sini kita akan menggunakan subskrip token untuk menunjukkan bahwa TeX memproses nilai token integer. 3. `\expandafter` membaca, lalu sementara menyimpan, `{`token dengan menyimpan nilai token integer tersebut dalam variabel internal. Kemudian, TeX akan menyisipkan kembali token itu ke input, setelah memproses `\jobname` perintah. 4. `\expandafter` membaca token berikutnya, `\jobname`token, dan memperluas `\jobname` perintah. 5. Perluasan dari `\jobname` membuat daftar token sementara yang berisi urutan token karakter yang mewakili `.tex` nama file. Perhatikan bahwa semua token karakter yang dihasilkan oleh `\jobname` dihitung menggunakan kode kategori 12. 6. Setelah `\jobname` telah diperluas, TeX menyisipkan kembali token yang disimpan pada langkah 3 (`{`token) dan memasukkannya kembali ke input. TeX melakukan itu dengan membuat daftar token lain yang berisi *satu* `{`token 7. TeX sekarang telah selesai memproses `\expandafter`, sehingga menghasilkan dua daftar token yang siap digunakan sebagai sumber input TeX. TeX sekarang kembali ke pemrosesan `\uppercase` tetapi telah mengonfigurasi inputnya sedemikian rupa sehingga dua daftar token yang dibuat oleh `\expandafter` menjadi sumber token untuk `\uppercase`—yang kini melihat `\uppercase{`token``daftar token (karakter)`}`. `\uppercase` kini melihat urutan token karakter dan dapat menghasilkan hasil yang kita inginkan. 8. Setelah membaca semua token karakter yang dihasilkan oleh `\jobname`TeX kembali memperoleh token dari sumber input sebelumnya ( `.tex` file) dari sana ia akan membaca token berikutnya: penutup `}` yang diperlukan untuk mengakhiri daftar token yang akan diproses oleh `\uppercase`. ### \expandafter dan daftar token internal Daftar token sementara adalah sebuah *penting* unsur dari `\expandafter`perilaku pemrosesan: memahami penggunaan dan keberadaan daftar token tersebut dapat membantu memperjelas bagaimana `\expandafter` mencapai hasilnya, khususnya saat mencoba menulis, atau memahami, makro yang menggunakan beberapa `\expandafter` perintah berurutan untuk mencapai bentuk pemrosesan token yang lebih kompleks: `\expandafter\expandafter\expandafter...` Elemen kunci lainnya dari `\expandafter`perilakunya, terutama dengan beberapa `\expandafter` perintah berurutan, adalah penggunaan *rekursi* (di dalam perangkat lunak TeX sendiri)—topik yang akan kita bahas nanti dalam artikel ini. Untuk lebih membantu pemahaman kita tentang daftar token sementara, kita akan melihat satu contoh lagi dari `\expandafter`, kali ini dengan `\the` perintah. #### contoh 2 Dalam contoh ini kita akan melihat bagaimana `\expandafter` dapat digunakan untuk memengaruhi token yang disimpan dalam register token melalui `\toks` perintah. Berikut primitif TeX yang akan kita gunakan: * `**\count** *register*=*number*`: primitif TeX yang digunakan untuk menyimpan nilai `*angka*` di lokasi TeX `*register*`; * `**\toks** *register*={*token list*}`: primitif TeX yang digunakan untuk menyimpan `*daftar token*` ke lokasi register token `*register*`—menyimpan urutan token untuk digunakan nanti; * `**\the** *token*`: perintah primitif TeX yang dapat diperluas yang memproses `*token*`, meskipun hasil pastinya bergantung pada sifat `*token*` yang sedang diproses. `\the` memiliki sejumlah kegunaan: di antaranya adalah menata nilai yang disimpan dalam parameter atau variabel TeX (misalnya, sebuah register). Kegunaan lain dari `\the` mencakup menyisipkan salinan token yang disimpan dalam register token. Di sini, kita akan menggunakan `\the` untuk menata nilai yang disimpan dalam sebuah `\count` register. Kita akan mulai dengan kode TeX berikut untuk menyimpan nilai `12345` di `\count` register `99`: ``` \count99=12345 ``` Jika kita ingin menata nilai yang disimpan dalam `\count99` kita dapat menggunakan `\the\count99` (atau `\number\count99`). Selanjutnya kita akan menggunakan `\toks` perintah untuk menyimpan beberapa token dalam register token `99`: ``` \toks99={\the\count99 } ``` Daftar token yang disimpan dalam register token `99` akan berisi hal berikut: | | | | ------------------- | -------------------------------------------------------------------------------------------------------------------- | | **Nilai token TeX** | **Item yang diwakili** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (kode karakter 57 dengan kode kategori 12) menghasilkan nilai token sebesar $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (kode karakter 57 dengan kode kategori 12), menghasilkan nilai token sebesar $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (kode karakter 32 dengan kode kategori 10), menghasilkan nilai token sebesar $$256 \times 10 + 32 = 2592$$ | Perhatikan bahwa daftar token yang dibuat oleh `memang` tidak *berisi nilai data aktual yang disimpan dalam* karena `\count99` perintah tidak melakukan perluasan: ia hanya membuat token dan menyimpannya. Dalam contoh kita, `\toks` tidak diperluas sehingga ia tidak memproses `\the` ; di sini `\count99`hanya diubah menjadi sebuah token (nilai 5382) dan disimpan dalam daftar token. `\the` hanya diubah menjadi sebuah token (nilai 5382) dan disimpan dalam daftar token. Jika kita ingin `memang` daftar token berisi token yang mewakili data yang disimpan dalam `\count99` kita memerlukan cara untuk membuat token-token tersebut (menjadikannya tersedia) agar `\toks` perintah dapat mengaksesnya. Dan tentu saja `\expandafter` dapat melakukan ini untuk kita. Jika kita menulis: ``` \toks99=\expandafter{\the\count99 } ``` aksi/pemrosesan dari `\toks` perintah akan “ditahan” sementara `\expandafter` menyebabkan (memaksa) perluasan dari `\the` yang, pada gilirannya, bekerja pada `\count` untuk menghasilkan daftar token sementara yang berisi token karakter yang mewakili data yang disimpan dalam `\count99`. Satu poin kecil namun penting adalah `` karakter setelah angka-angka `99`: karakter itu `` berfungsi mengakhiri proses pemindaian TeX saat ia mencari suatu kuantitas numerik. Di sini, aksi dari `\expandafter` sangat mirip dengan `\jobname` contoh. 1. Baca dan simpan pembuka `{`token. 2. Baca token berikutnya, `\the`token, yang mewakili perintah yang dapat diperluas, sehingga TeX memperluasnya. `\expandafter` memaksa perluasan dari `\the` yang kemudian bekerja pada `\count99` untuk mengubah data yang disimpan dalam `\count` register `99` (angka 12345) menjadi daftar token sementara. Daftar itu akan berisi token karakter yang mewakili digit `1`, `2`, `3`, `4` dan `5`—token karakter dengan kode kategori 12. 3. Setelah memperluas dan memproses `\the`, TeX memasukkan `{`token “kembali ke input” dan menggunakan daftar token yang dihasilkan dari `\the\count99` agar TeX akan membaca `\toks99={`token``daftar token (karakter)`}` dan ini menghasilkan hasil yang kita inginkan. Rangkaian peristiwa ini dirangkum dalam diagram berikut—bacalah grafik dari bawah dan bergerak ke atas untuk mengikuti alur proses. ![Cara kerja \expandafter](/files/1e5e96d127a918a4d63726c40f864713be3c34ef) 1. TeX mulai memproses `\toks`; ia melihat tanda opsional `=` lalu memeriksa karakter kurung kurawal pembuka wajib (`{`, atau karakter apa pun dengan kode kategori 1) yang digunakan untuk menandai awal daftar token. Namun, TeX mendeteksi sebuah `\expandafter` perintah dan malah melanjutkan untuk menjalankannya. 2. Jika kita membandingkan `\expandafter` $$\mathrm{T\_1T\_2}$$ pada input kita berupa `\expandafter{\the\count99 }` kita dapat melihat $$\mathrm{T\_1} =$$ `{`token dan $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` membaca, lalu sementara menyimpan, `{`token (TeX sementara menyimpan nilai token integer itu dalam variabel internal). Kemudian, TeX akan menyisipkan kembali token itu ke input, setelah memproses `\the` 4. `\expandafter` membaca token berikutnya, `\the`token dan memperluasnya. 5. Perluasan dari `\the` membuat daftar token sementara dari pemrosesan `\count99`—daftar token itu berisi urutan token karakter yang mewakili nilai data yang disimpan dalam `\count` register `99`. 6. Setelah `\the` telah diperluas, TeX menyisipkan kembali token yang disimpan pada langkah 3 (`{`token) dan memasukkan token itu kembali ke input. TeX melakukan itu dengan membuat daftar token lain yang berisi *satu* token `{`token. 7. TeX sekarang telah selesai memproses `\expandafter` dan menghasilkan dua daftar token yang siap digunakan sebagai sumber input berikutnya. TeX kembali ke pemrosesan `\toks99=` tetapi sekarang TeX telah mengonfigurasi inputnya sehingga dua daftar token yang dibuat oleh `\expandafter` menjadi sumber token untuk `\toks`—yang kini melihat `{`token``daftar token (karakter)`}`. `\toks` kini dapat mengakses, dan menyimpan, urutan 5 token karakter yang mewakili nilai data (`12345`) yang disimpan dalam `\count99`: hasil yang kita inginkan. 8. Setelah membaca semua token karakter yang dihasilkan oleh `\the\count99`TeX kembali memperoleh token dari sumber input sebelumnya ( `.tex` file) dari sana ia akan membaca token berikutnya: penutup `}` yang diperlukan untuk mengakhiri daftar token yang akan disimpan oleh `\toks99={...}`. ## Cara kerja \expandafter yang sebenarnya Dalam bagian ini kita akan melihat secara “level rendah” ke dalam TeX itu sendiri: menelusuri kode sumber/fungsi di dalam TeX yang mengimplementasikan perilaku `\expandafter`. Rinciannya dinyatakan dalam kode pseudo-C tetapi seharusnya dapat dipahami oleh siapa pun yang akrab dengan bahasa pemrograman lain. Diagram beranotasi berikut menjelaskan bagaimana TeX mengimplementasikan `\expandafter` sebagai bagian dari fungsi yang lebih besar bernama `expand()`—fungsi inti yang menggerakkan pemrosesan perluasan TeX. Dalam bagian yang bertanggung jawab mengimplementasikan `\expandafter` kita dapat melihat [*rekursif* perilaku](https://en.wikipedia.org/wiki/Recursion) di mana pemanggilan lain ke `expand()` fungsi digunakan untuk memproses token kedua yang dibaca, $$\mathrm{T\_2}$$untuk kasus-kasus ketika $$\mathrm{T\_2}$$ dapat diperluas. Meskipun kode ini muncul dalam mesin TeX milik Knuth, prinsip-prinsip dasar yang diuraikan oleh grafik ini berlaku untuk semua mesin TeX. ![Cara kerja \expandafter di dalam TeX](/files/7be2a219ef2d8f5a21b7fdbbbd9abcfa1a1bd612) Tugas pertama dari `expand()` adalah menentukan apakah perintah yang akan diperluas adalah makro atau primitif karena makro memiliki proses perluasan khusus yang ditangani oleh fungsi bernama `macrocall()`. Jika perintah yang akan diperluas adalah primitif, `expand()` fungsi menggunakan nilai kode perintah saat ini (disimpan dalam variabel global `curcmd`) untuk mengidentifikasi primitif tertentu yang perlu diproses. Kita dapat melihat rincian ini dalam daftar yang lebih lengkap dari `expand()`: ``` void expand(void) { //curcmd adalah variabel global if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Proses perintah \expandafter T1T2 { gettoken(); // Baca token T1 t = curtok; // Simpan token T1 dalam variabel lokal t gettoken(); // Baca token T2 if(curcmd > 100) // Apakah token T2 dapat diekspansi? expand(); // Ya! T2 dapat diekspansi: // lakukan ekspansi T2 dengan // membuat pemanggilan fungsi rekursif ke expand() else backinput(); // T2 tidak dapat diekspansi: letakkan token itu // kembali ke input untuk dibaca lagi (nanti) curtok = t ; // Pulihkan variabel global curtok ke nilai tersimpan dari T1 backinput() ; // Masukkan kembali token T1 ke dalam input // di depan token-token yang muncul dari ekspansi T2 } break; // Kode untuk memproses perintah lain yang dapat diekspansi case “perintah ‘ubah ke teks’”: // Salah satu dari \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Mereka berbagi nilai curcmd yang sama break; case \noexpand: // Cegah ekspansi token berikutnya ... break; case \csname: //Buat nama urutan kontrol. ... break; case \the: // Sisipkan beberapa token .... break; case “perintah uji \if...” : // Proses salah satu kondisional TeX: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi atau \else”: // Akhiri kondisional saat ini ... break; // dll. untuk perintah primitif lain yang dapat diekspansi yang didukung oleh // mesin TeX } }else // Bukan primitif yang dapat diekspansi: itu adalah makro { macrocall() } //... lebih banyak kode dihapus } ``` ### Kecintaan TeX pada variabel global Mungkin mencerminkan usianya dan era saat TeX dirancang, kode sumber TeX banyak menggunakan apa yang disebut [variabel global](https://en.wikipedia.org/wiki/Global_variable)—bahkan ada ratusan. Secara hakikatnya, variabel global dapat diubah/dimodifikasi dari mana saja di dalam kode sumber TeX—yang, untuk TeX karya Knuth, merupakan satu berkas monolitik berisi lebih dari 25.000 baris kode dan ratusan fungsi. Memahami cara kerja TeX tidak selalu merupakan tugas yang mudah... Untuk memproses `\expandafter`, TeX membaca token dari input saat ini menggunakan fungsi bernama `gettoken()` yang tindakannya adalah membuat sebuah token dan menetapkan nilai beberapa variabel global kunci yang digunakan di seluruh kode sumber TeX. Dua variabel seperti itu, yang diperbarui oleh aksi `gettoken()`, digunakan dalam implementasi `\expandafter`: * `curtok`: (token saat ini) nilai integer dari token yang baru saja dibaca; * `curcmd`: (kode perintah saat ini) kode perintah dari perintah (atau karakter) yang diwakili oleh token `curtok`. Saat memproses `\expandafter`$$\mathrm{T\_1T\_2}$$ TeX membaca token $$\mathrm{T\_1}$$ dan untuk sementara menyimpan nilainya (sebuah integer) dalam variabel lokal bernama `t`. TeX kemudian membaca $$\mathrm{T\_2}$$ dan memeriksa apakah token itu merepresentasikan perintah yang dapat diekspansi—dengan memeriksa apakah kode perintahnya (`curcmd`) > 100. Jika ya, TeX perlu mengekspansi perintah yang diwakili oleh $$\mathrm{T\_2}$$ dan melakukan pemanggilan lain ke fungsi `expand()`: ini adalah contoh *rekursi* perintah tidak melakukan perluasan: ia hanya membuat token dan menyimpannya. Dalam contoh kita, `expand()` fungsi memanggil dirinya sendiri. Kesadaran akan sifat rekursif dari ekspansi, terutama saat menggunakan `\expandafter`, dapat membantu memahami bagaimana beberapa `\expandafter` perintah—yaitu, `\expandafter\expandafter\expandafter...` mencapai efeknya. Jika token $$\mathrm{T\_2}$$ dapat diekspansi, ekspansi dilakukan dan ketika pemanggilan rekursif ke `expand()` mengembalikan nilai, kode di dalam implementasi `\expandafter` menyisipkan kembali token $$\mathrm{T\_1}$$ ke dalam input. Variabel global `curtok` ditetapkan ulang ke nilai token yang disimpan—disimpan dalam variabel lokal `t`, yang merupakan nilai token $$\mathrm{T\_1}$$—dan pemanggilan dilakukan ke fungsi `backinput().` #### Fungsi backinput() Seperti namanya, fungsi ini menempatkan sebuah token “kembali ke dalam input”. Untuk melakukannya, TeX menggunakan nilai saat ini dari variabel global `curtok` untuk membuat daftar token yang berisi satu token (yang nilai integernya disediakan oleh `curtok`). TeX juga mengatur penanganan inputnya untuk memastikan bahwa daftar berisi satu token itu, pada waktu yang tepat, akan dibaca ulang oleh TeX sebagai bagian dari pemrosesan input berikutnya. Perhatikan dengan saksama bahwa token $$\mathrm{T\_1}$$ disisipkan kembali *setelah ekspansi selesai*, yang memastikan TeX akan membaca token yang disisipkan kembali itu *sebelum* ketika ia membaca token-token yang muncul dari ekspansi $$\mathrm{T\_2}$$. ### Memproses makro: fungsi macrocall() Seperti telah dibahas sebelumnya, semua makro, bersama beberapa perintah primitif, dapat diekspansi dan semua pemrosesan ekspansi melalui `expand()` fungsi. Namun, `expand()` berhati-hati menggunakan `curcmd` (perintah saat ini) untuk membedakan antara primitif yang dapat diekspansi dan makro karena proses ekspansi makro ditangani oleh fungsi khusus bernama `macrocall()`. Makro memerlukan proses ekspansi khusus karena argumen makro dan token pembatas harus dipindai dengan cara yang sangat khusus dan ketat; akibatnya, proses itu didelegasikan kepada fungsi yang dirancang untuk melakukan itu: `macrocall()`. #### Ekspansi makro vs. eksekusi makro Makro *ekspansi* bukan proses yang sama dengan makro *eksekusi*: ekspansi sebuah makro adalah proses sebelum eksekusi yang dilakukan TeX untuk menyiapkan makro *siap dieksekusi*. “Eksekusi” sebuah makro terjadi ketika TeX secara aktif membaca dan memproses token yang terkandung dalam definisi makro itu (teks pengganti) dan argumennya (parameter). #### Ekspansi makro Untuk mengekspansi sebuah makro, TeX terlebih dahulu memeriksa apakah makro tersebut menerima argumen; jika ya, `macrocall()` memindai input dengan sangat cermat untuk mencari token yang akan menjadi argumen makro. Proses itu mencakup memeriksa input pengguna terhadap token pembatas apa pun yang digunakan dalam definisi asli makro—pola token yang digunakan dalam panggilan makro harus benar-benar cocok dengan pola token yang terdapat dalam definisi tersimpan. Namun, token yang digunakan sebagai pembatas hanya dibuang oleh TeX: pada dasarnya, token tersebut hanyalah bentuk “tanda baca” yang digunakan TeX untuk menentukan token sebenarnya yang akan menjadi argumen makro—yaitu token yang dimaksudkan pengguna untuk diproses oleh makro. Untuk informasi lebih lanjut tentang token pembatas, lihat [Bagaimana makro TeX sebenarnya bekerja](/latex/id/topik-lainnya/22-how-tex-macros-actually-work-part-4.md). Untuk setiap parameter (`#1, #2...#9`) yang ada dalam definisi asli makro, TeX memindai panggilan makro yang sebenarnya untuk mengidentifikasi token mana yang disediakan pengguna yang ditujukan untuk setiap parameter (yaitu, membentuk argumen makro). Proses itu menghasilkan satu atau beberapa daftar token mini: satu untuk setiap argumen makro. Setelah argumen makro terdeteksi dan daftar tokennya disiapkan, TeX mengambil definisi makro (teks pengganti) yang disimpan dalam memorinya dan mengatur pemrosesan inputnya sedemikian rupa sehingga kapan pun TeX siap membaca/memproses lebih banyak token, ia akan membacanya dari teks pengganti makro, sehingga mengeksekusi makro. Pada titik yang tepat, selama eksekusi makro, daftar token yang mewakili argumen makro akan dimasukkan ke lokasi yang benar dalam teks pengganti makro. Sekali lagi, ekspansi sebuah perintah makro berarti *menghapus* perintah makro (token) itu dari input dan *menggantinya* dengan daftar token yang disimpan sebagai teks pengganti makro. Untuk melihat lebih dalam pemrosesan makro TeX, lihat seri artikel enam bagian [Bagaimana sebenarnya cara kerja makro TeX?](/latex/id/topik-lainnya/01-a-six-part-series-how-do-tex-macros-actually-work.md) [Bagian 1](/latex/id/artikel-mendalam/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Bagian 2](/latex/id/artikel-mendalam/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Bagian 3](/latex/id/artikel-mendalam/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Bagian 4](/latex/id/artikel-mendalam/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Bagian 5](/latex/id/artikel-mendalam/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Bagian 6](/latex/id/artikel-mendalam/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://overleaf-pro.ayaka.space/latex/id/artikel-mendalam/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.