> 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/54-what-is-a-tex-token-list.md). # Apa itu daftar token TeX ## Jadi, sebenarnya apa itu "daftar token TeX"? Dalam sebuah [artikel sebelumnya](/latex/id/artikel-mendalam/53-what-is-a-tex-token.md)—juga bagian dari ini [seri tentang hal-hal teknis TeX tingkat rendah](/latex/id/artikel-mendalam/01-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how.md)—kami menelusuri proses yang digunakan TeX untuk memindai `.tex` berkas Anda guna menghasilkan token baru: kami menelaah sifat dasar sebuah token TeX dan bagaimana TeX membuatnya (lihat [Apa itu "token TeX"?](/latex/id/artikel-mendalam/53-what-is-a-tex-token.md)). Dalam artikel lanjutan ini kita melihat *daftar token*s: apa itu dan bagaimana mesin TeX membuat/menggunakannya. Memahami daftar token bisa rumit karena daftar ini disimpan jauh di dalam internal TeX: rincian itu tersembunyi dari pengguna—meskipun, saat ini, hal itu tidak selalu benar jika Anda melakukan pemrograman yang lebih lanjut dengan LuaTeX. Namun, untuk saat ini, Anda dapat mulai memandang daftar token sebagai cara TeX menyimpan serangkaian nilai integer, di mana setiap integer adalah token yang diturunkan dari sebuah karakter atau perintah yang telah dibaca TeX dari berkas input Anda. Daftar token memainkan peran penting dalam operasi internal TeX, sering kali dengan cara yang mengejutkan, seperti dalam operasi internal perintah seperti `\uppercase` dan `\lowercase`. Salah satu penggunaan daftar token yang sangat penting adalah menyimpan dan mengeksekusi makro, topik yang akan kita bahas secara rinci sebagai bagian dari artikel mendatang dalam seri ini. ### TeX mendapatkan inputnya dari berkas dan daftar token Mesin TeX memiliki tiga sumber input—dua di antaranya mungkin Anda kenal: * berkas teks fisik yang disimpan di disk; * teks yang diketik pengguna ke terminal (baris perintah); tetapi juga memiliki cara ketiga untuk membaca/memperoleh input: daftar token! Pada praktiknya, daftar token adalah fasilitas penyimpanan data internal yang digunakan TeX sebagai bagian dari operasinya. Karena daftar token TeX berfungsi sebagai “fasilitas penyimpanan” bagi token yang telah dibuat sebelumnya, masuk akal bagi TeX untuk dapat menggunakannya kembali sebagai sumber input lain. Ketika perlu mengambil input berikutnya dari daftar token tertentu (atau ketika TeX diperintahkan untuk melakukannya), TeX akan untuk sementara henti membaca input dari berkas fisik (yaitu, membuat *token baru*) dan beralih ke memperoleh inputnya dari *token yang sudah ada*: lokasi di memori tempat daftar token disimpan. Jelas, dengan daftar token proses pemindaian + pembuatan token sudah terjadi sehingga TeX hanya perlu melihat setiap token dalam daftar dan memutuskan apa yang harus dilakukan dengan masing-masing token. Sebagai contoh singkat, perintah tingkat rendah (primitif TeX) `\toks` memungkinkan Anda membuat daftar token yang disimpan TeX di memori untuk digunakan kembali nanti: ```latex \toks100={Hello} ``` Untuk mengambil kembali token-token tersebut (yaitu, menyuruh TeX memperlakukannya sebagai sumber input berikutnya), Anda dapat memberikan perintah seperti ```latex \the\toks100 ``` Ini akan membuat TeX beralih dari membuat token baru dari berkas input Anda ke mengambil input berikutnya dari tempat token-token tersebut (yang dibuat oleh `\toks`) disimpan—dalam sebuah *register token* yang hanya merupakan lokasi memori internal yang dikenal oleh TeX (di sini itu adalah register 100). Selain itu, daftar token dapat dibuat secara internal, secara spontan, oleh sejumlah perintah TeX. Salah satu contohnya adalah perintah `\jobname` yang menghasilkan serangkaian token karakter—satu token untuk setiap karakter dalam nama berkas utama yang sedang diproses TeX. Contoh lain adalah perintah `\string` perintah; misalnya ```latex \string\mymacro ``` menghasilkan serangkaian token karakter untuk setiap huruf dalam nama `\mymacro`—termasuk karakter awal `\` karakter. Kita akan melihat lebih dekat beberapa “perintah penghasil token” di akhir artikel ini. ## Daftar token: dijelaskan lewat analogi Kecuali Anda memiliki latar belakang pemrograman dan/atau sedikit pengetahuan ilmu komputer, “daftar token” mungkin merupakan konsep yang agak samar, dan, mungkin, sedikit membingungkan. Namun, jika Anda ingin mahir menulis makro TeX/LaTeX maka pemahaman yang baik tentang topik seperti token TeX, daftar token, dan kode kategori (`\catcode`) akan terbukti sangat berguna. Dalam bagian ini kita akan menggunakan analogi untuk menjelaskan/mengilustrasikan gagasan/prinsip inti dari daftar token TeX: bagaimana TeX menyimpan token di memori. Ada baiknya meluangkan waktu untuk membaca ini karena daftar token adalah aspek yang *mendasar* aspek mendasar TeX dan layak dipahami sedikit lebih rinci. ### Daftar token: Sebuah analogi (eksperimen pikiran) Kita akan melalui sebuah “eksperimen pikiran” untuk memberikan dasar memahami daftar token TeX. Bayangkan Anda memiliki akses ke seperangkat besar wadah, seperti ratusan kaleng—kita tidak bisa mempertimbangkan atau menggunakan istilah “kotak” untuk menggambarkan wadah dalam eksperimen pikiran ini karena, tentu saja, “box” memiliki makna yang sangat spesifik dalam TeX, yang tidak ada kaitannya dengan pembahasan kita di sini. Jadi kita akan menyebut wadah kita “Kaleng”, di mana setiap Kaleng: * memiliki nomor identifikasi unik yang tercetak di bagian luarnya; * dibagi secara (internal) menjadi dua kompartemen. Kedua kompartemen itu dirancang sebagai berikut: * kompartemen kiri menampung benda yang ingin Anda masukkan ke dalam Kaleng; * kompartemen kanan dirancang untuk menampung selembar kertas tempat Anda dapat menulis satu nomor: nomor yang mengidentifikasi Kaleng lain. ![tes](/files/aec2c69d5aa54e50dd7f271ad125eaf67450604f) Misalkan Anda memiliki kumpulan, katakanlah, 5 benda, dan Anda ingin menyimpan kumpulan benda itu dalam Kaleng-kaleng tersebut; tetapi sayangnya, setiap Kaleng hanya dapat menampung 1 benda dari jenis yang ingin Anda simpan. Untuk menyederhanakan, anggaplah kita ingin menyimpan 5 lingkaran berwarna: ![{{{alt}}}](/files/4f87ba9d9144cb5309abe89b5ea1b3f253410808) Selanjutnya, ketika Anda kembali untuk mengambil benda-benda itu dari sistem penyimpanan Anda (Kaleng), benda-benda itu *harus* harus diambil/ditemukan dalam urutan tertentu—urutan saat benda-benda itu disimpan: urutan tersebut harus dipertahankan. Bagaimana Anda bisa mencapainya? Kita dapat memanfaatkan fakta bahwa setiap Kaleng: * memiliki nomor identifikasi unik yang ditempel di bagian luarnya; * memiliki 2 kompartemen—hanya 1 yang akan kita gunakan untuk memuat benda kita, yang lain berisi selembar kertas dengan nomor Kaleng lain tertulis di atasnya. Kita akan mengasumsikan setiap Kaleng kosong—tetapi tidak ada yang menghalangi Anda membuka Kaleng tertentu untuk memeriksa apakah ia kosong; jika tidak, coba yang berikutnya sampai Anda menemukan Kaleng kosong. Yang bisa kita lakukan adalah sebagai berikut. Masukkan benda pertama kita (lingkaran hijau tua) ke salah satu Kaleng kita (mis., Kaleng 124) dan catat nomor Kaleng pertama itu—tidak masalah nomor berapa yang dimiliki Kaleng pertama, yang penting kita menuliskannya di suatu tempat dan menyimpannya untuk digunakan nanti. ![{{{alt}}}](/files/eac654556c2d48f729e55a7c7b22f27bb9c030fd) Cari Kaleng kedua—nomor Kaleng mana saja (mis., Kaleng 432)—dan catat nomornya. Tulis nomor Kaleng kedua itu (432) pada selembar kertas dan letakkan catatan itu *ke dalam Kaleng pertama* (Kaleng 124). Kita menempatkan benda kedua kita (lingkaran hijau muda) ke dalam Kaleng kedua. Jadi, saat ini kita memiliki keadaan berikut: * sebuah catatan tertulis—tidak disimpan di dalam Kaleng—yang menyatakan bahwa Kaleng pertama bernomor 124 (dan berisi benda pertama kita); * di dalam Kaleng 124 kita telah menambahkan catatan lain yang mengatakan bahwa benda berikutnya berada di Kaleng 432. Pada dasarnya, kita telah *menghubungkan* dua Kaleng pertama kita: kita tahu harus mulai dari mana (Kaleng 124) dan bahwa sebuah catatan di Kaleng 124 memberi tahu kita Kaleng mana yang berisi benda berikutnya (Kaleng 432). ![{{{alt}}}](/files/ff9ca6da30b24c5b49d78ca308cdf859ccadf38b) Kemudian kita menemukan Kaleng ketiga, menuliskan nomornya (mis., Kaleng 543) pada selembar kertas dan meletakkannya di *kedua* Kaleng (nomor 432). Lalu kita menempatkan benda ketiga kita (lingkaran merah) ke dalam Kaleng ketiga. Sekarang kita telah menghubungkan tiga Kaleng dalam urutan: titik awal kita, Kaleng 124 (lingkaran hijau tua) → Kaleng 432 (lingkaran hijau muda)→Kaleng 543 (lingkaran merah) →… ![{{{alt}}}](/files/a4f474a57fb49945daf81b5d1575b8b6199807ec) Ulangi proses ini untuk dua benda terakhir (lingkaran biru muda dan biru tua) menggunakan Kaleng 213 (lingkaran biru muda) dan Kaleng 102 (lingkaran biru tua). ![{{{alt}}}](/files/b1748dff19b04184cacb1f350d7cb20e771b0824) Sekarang kita memiliki semua 5 Kaleng yang terhubung (menggunakan pengenal numerik setiap Kaleng) dan dapat mengambil semua benda yang disimpan—dalam urutan yang benar—hanya dengan mengunjungi setiap Kaleng secara bergiliran, mengambil benda kita, dan melihat catatan yang memberitahu Kaleng mana yang berisi benda berikutnya. ### Bagaimana dengan benda terakhir dalam daftar kita (Kaleng 102)? Mengapa kita perlu memikirkan yang ini secara khusus? Sampai sekarang kita telah menyimpan setiap benda di dalam Kaleng, bersama catatan yang menyatakan Kaleng mana yang berisi benda berikutnya: untuk benda terakhir dalam daftar kita, apa yang harus dikatakan catatan itu—karena tidak ada Kaleng berikutnya. Ketika kita mencapai benda (Kaleng) terakhir, harus jelas bahwa Kaleng ini (yang berisi benda terakhir) adalah benda terakhir dalam daftar kita—kita tidak perlu mencari Kaleng lain, karena memang tidak ada. Salah satu cara melakukannya adalah dengan meletakkan nomor Kaleng “khusus” di dalam Kaleng terakhir kita (102). Kita dapat menggunakan nomor apa pun asalkan kita memilih nomor unik yang bukan nomor Kaleng sungguhan—misalnya “Kaleng -1”, “Kaleng 0”: tidak masalah selama kita tahu bahwa “Kaleng -1” atau “Kaleng 0” dan seterusnya langsung memberi tahu kita untuk berhenti mencari: kita tidak perlu mencari Kaleng lagi karena ini yang terakhir dan karenanya tidak ada benda lagi untuk diambil. ### Dari “benda” dan “Kaleng” ke token dan TeX Sekarang kita perlu beralih dari analogi kita ke deskripsi yang lebih dekat dengan realitas TeX. Pertama, alih-alih menyimpan lingkaran dengan warna berbeda dalam Kaleng imajiner kita, seharusnya jelas bahwa kita dapat memandang Kaleng-kaleng itu sebagai penyimpan token TeX: bilangan bulat sederhana. Itulah bagian yang lebih mudah dalam memindahkan analogi kita ke ranah perangkat lunak (TeX). Tetapi apa padanan perangkat lunak dari Kaleng bernomor fisik kita yang memiliki “kompartemen”? Kita tidak ingin terlalu jauh memasuki konsep pemrograman, tetapi Anda dapat menganggap “Kaleng” kita sebagai beberapa byte memori komputer yang telah “dikemas” menjadi satu unit penyimpanan yang praktis. Penggunaan pengenal numerik untuk setiap Kaleng dalam analogi kita dapat dianggap sebagai lokasi di dalam memori komputer tempat setiap paket kecil memori berada. Di dalam TeX sendiri, paket-paket kecil penyimpanan itu disebut “kata memori”—istilah yang mencerminkan waktu/era saat TeX dibuat (tahun 1970-an). “Kata memori” ini adalah blok dasar yang digunakan dalam TeX, tetapi kita tidak perlu membahasnya lebih rinci di sini—siapa pun yang ingin rincian lebih lanjut dapat merujuk pada artikel tentang [blog pribadi penulis](http://www.readytext.co.uk/?p=3537). Dalam istilah pemrograman komputer, apa yang telah kita bahas disebut sebuah [*daftar tertaut*](https://en.wikipedia.org/wiki/Linked_list): daftar token TeX adalah daftar tertaut yang dibangun dari wadah penyimpanan TeX yang disebut *kata memori* di mana setiap kata memori dapat digunakan untuk menyimpan: * a *nilai*: nilai token (sebuah bilangan bulat); * a *tautan*: lokasi memori dari kata memori berikutnya yang berisi token berikutnya dalam daftar kita. ## Di mana TeX menggunakan daftar token? Di mana-mana! Ini benar karena definisi makro TeX/LaTeX (mis., sebuah perintah LaTeX) disimpan sebagai bentuk daftar token yang (sedikit) khusus—khusus dalam arti berisi token yang tidak Anda lihat dalam daftar token “standar” (terkait pencocokan parameter makro, dll). Jangan khawatir tentang ini karena kami akan membahas detail tersebut dalam artikel mendatang. ### Contoh makro Sebuah makro dapat dianggap terdiri dari tiga bagian: ``` \def\{} ``` Perhatikan bahwa alih-alih `\def` Anda bisa menggunakan `\edef`, `\gdef` atau `\xdef`. **Catatan untuk pengguna LaTeX**: Di sini kita mendefinisikan makro menggunakan perintah TeX mentah tingkat rendah (disebut *primitif*). Pengguna LaTeX akan lebih akrab membuat makro melalui `\newcommand` (yang itu sendiri adalah sebuah makro). Ketika Anda meminta TeX untuk membuat (mendefinisikan) sebuah makro, TeX akan membuat sebuah token yang mewakili `` hanyalah sebuah *daftar token* yang mewakili gabungan `` dan ``. TeX akan menyimpan semuanya dengan cermat sehingga token yang mewakili `` terhubung ke daftar token yang mewakili definisinya (`` dan ``). Misalnya, jika kita mendefinisikan `\mymacro` seperti ini: ```latex \def\mymacro abc #1 defz{Saya mengetikkan "#1"!} ``` Kita dapat melihat bahwa bagian-bagiannya adalah: * `` = `mymacro` * `` = `abc #1 defz` * `` = `Saya mengetikkan "#1"!` Misalnya, Anda bisa memanggil `\mymacro` seperti ini: ```latex \mymacro abc TEKS INI defz ``` yang menghasilkan `Saya mengetikkan "TEKS INI"!` dicetak— `abc` dan `defz` sudah *berisi nilai data aktual yang disimpan dalam* dicetak. `abc` dan `defz` adalah urutan token karakter yang digunakan untuk *membatasi* parameter makro `#1` dan diserap lalu dibuang ketika pemanggilan makro Anda berhasil diproses oleh TeX. Ketika Anda mendefinisikan `\mymacro`, pola token yang terkandung dalam yang tersimpan berfungsi sebagai “templat” yang dapat digunakan TeX untuk menentukan: * token mana dalam input Anda yang merupakan token pembatas; * token mana dalam input Anda yang benar-benar membentuk parameter makro Anda (di sini, yang Anda gunakan sebagai `#1` dalam pemanggilan `\mymacro`). Anda harus memanggil `\mymacro` dengan sebuah `` yang mengandung pembatas yang identik dengan yang digunakan untuk mendefinisikannya—termasuk menggunakan pembatas karakter dengan kode kategori yang identik. Jika pembatas dalam `` yang digunakan untuk memanggil `\mymacro` berbeda dari yang digunakan untuk mendefinisikannya (”templat” yang tersimpan di memori), maka TeX bisa menjadi agak bingung—ketika mencoba memproses `\mymacro` ia tidak akan dapat mencocokkan “templat” yang telah disimpannya di memori. Ketika TeX melihat bahwa Anda sedang memanggil sebuah makro, ia akan memindai teks input Anda untuk membuat token baru dan mencoba, token demi token, mencocokkannya dengan daftar token `` templat yang disimpan sebagai bagian dari definisi makro Anda. Jika pembatas yang digunakan dalam teks input Anda menghasilkan serangkaian token yang tidak cocok dengan yang tersimpan dalam “templat”, biasanya TeX akan memunculkan kesalahan. TeX sangat teliti—ingat bahwa token karakter adalah gabungan kode karakter dan kode kategori: jika Anda mengubah kode kategori sebuah karakter, Anda mendapatkan nilai token yang berbeda yang dihasilkan oleh karakter itu. Misalkan kita mengubah kode kategori dari `z` menjadi, katakanlah, 12—biasanya nilainya 11—dan mencoba memanggil makro kita seperti ini: ```latex \catcode`z=12 \mymacro abc TEKS INI defz teks lebih lanjut di sini... ``` Kali ini tidak akan berhasil karena kode kategori dari `z` telah diubah. Anda akan melihat kesalahan seperti ini: ```latex Argumen kabur? TEKS INI defz ! Paragraf berakhir sebelum \mymacro selesai. \par l.22 ``` Ketika TeX membaca dan memindai `z` di `defz` TeX tidak dapat mengenalinya sebagai penanda akhir dari `\mymacro`’s `` yang digunakan dalam berkas input Anda. Sampai melihat `z` yang keliru itu, TeX telah mencocokkan 3 karakter pertama dengan benar `def` tetapi itu `z` (dengan kode kategori 12) mengacaukan pemindaian TeX. Dengan asumsi `z` memiliki kode kategori 11 ketika kita *mendefinisikan* `\mymacro`: itu akan menghasilkan nilai token 256×11 + 122 = 2938 yang disimpan sebagai bagian dari `\mymacro`’s definition (yaitu, disimpan sebagai bagian dari “templat”). Namun, dengan kode kategori 12, `z` akan sekarang membuat nilai token 256×12 + 122 = 3194. Karena nilai token (untuk `z`) yang dibaca dari input Anda (nilai 3194) tidak cocok dengan `z`-token yang terkandung dalam `` templat daftar token (nilai 2938), TeX akan terus memindai input Anda. TeX akan terus memindai teks yang mengikuti makro Anda (*teks lebih lanjut di sini* ...) untuk mencari token tambahan—mencoba mencocokkan templat yang tersimpan dengan token yang ditemukannya dalam input Anda. Ia kemungkinan tidak akan menemukan pola token yang benar dan kesalahan akan terjadi karena TeX “melewati” input Anda dan secara keliru membaca teks tambahan untuk membuat token tambahan—token tambahan itu seharusnya belum dibaca pada titik ini dan hampir pasti akan menimbulkan kesalahan. Kita akan membahas ini lebih rinci dalam artikel mendatang. ## Penggunaan lain daftar token Perintah lain yang digunakan untuk membuat/menyimpan daftar token meliputi: ```latex \toks={...} \everypar={...} \everymath={...} \everydisplay={...} \everyhbox={...} \everyvbox={...} \output={...} \everyjob={...} \everycr={...} \errhelp={...} ``` Masing-masing perintah ini membuat daftar token dari karakter dan perintah di dalam kurung kurawal ‘{...}’ dan daftar token itu dimaksudkan untuk digunakan kembali dalam keadaan tertentu. Misalnya, `\everypar={...}` membuat dan menyimpan satu set token (daftar token) yang disisipkan TeX ke dalam input tepat sebelum memulai paragraf baru. ## Penggunaan tersembunyi daftar token: contoh Dalam bagian terakhir ini kita akan melihat beberapa contoh praktis penggunaan daftar token dengan cara yang mungkin tidak Anda duga. ### Contoh 1: \uppercase{...} dan \lowercase{....}—daftar token sementara Selain perintah eksplisit untuk menghasilkan daftar token, ada keadaan ketika TeX menghasilkan daftar token internal yang tersembunyi dan sementara untuk melakukan pemrosesan khusus. Ingat bahwa ketika TeX membaca/memproses karakter/perintah input Anda, semuanya diubah menjadi token: blok dasar mendasar yang digunakan mesin TeX. Contoh yang baik adalah perintah `\uppercase{...}` atau `\lowercase{...}` karena cara kerjanya, pada perjumpaan pertama, bisa agak membingungkan. Setelah Anda memahami apa yang mereka lakukan—lebih dalam di dalam TeX dan tidak terlihat oleh pengguna—operasinya menjadi jauh lebih mudah dipahami. Misalkan Anda memiliki rangkaian huruf sederhana yang ingin Anda jadikan huruf kapital—mis., abcde dan ubah menjadi ABCDE. Nah, itu cukup mudah dengan `\uppercase` perintah: ```latex \uppercase{abcde} ``` akan membuat TeX menghasilkan `ABCDE`. Sekarang misalkan kita ingin menyimpan rangkaian huruf sederhana itu untuk digunakan nanti—yaitu, kita tidak ingin langsung menampilkannya sehingga kita akan menggunakan satu-satunya *internal* mekanisme—bukan mekanisme eksternal (berkas)—untuk menyimpan data: gunakan daftar token. Kita dapat melakukannya dengan membuat makro atau menggunakan perintah daftar token eksplisit: ```latex \toks100={abcde} \def\mychars{abcde} ``` Lalu, pada suatu saat, Anda mungkin memutuskan ingin menggunakan kembali rangkaian huruf itu tetapi, kali ini, dalam huruf kapital; jadi Anda mencoba ```latex \uppercase{\the\toks100} ``` dan ```latex \uppercase{\mychars} ``` Tetapi sayangnya, keduanya tidak berhasil. Mengapa? ### Daftar token rahasia! Untuk memahami bagaimana perintah `\uppercase{...}` `\lowercase{...}` sebenarnya bekerja, saya perlu mengintip ke dalam cara kerja internal TeX sehingga penjelasan berikut berasal dari sana. Ketika TeX mendeteksi salah satu dari `\uppercase{}` atau `\lowercase{}` di input Anda, hal pertama yang dilakukan TeX adalah membuat daftar token internal (sementara) dari `` yang diapit oleh ‘{’ dan ‘}’ yang mengikuti `\uppercase{...}` atau `\lowercase{...}` perintah tersebut—daftar token sementara itu bersifat internal bagi TeX. Poin penting, dan inti untuk memahami bagaimana `\uppercase{}` dan `\lowercase{}` sebenarnya bekerja, adalah bahwa perintah atau makro apa pun yang terkandung di dalam `` tidak *diekspansi*: yang dilakukan TeX hanyalah menghasilkan token dari karakter dan perintah yang ditempatkan di antara `{...}`. Selama operasi `\uppercase{}` atau `\lowercase{}` tidak ada yang di dalam kurung kurawal dieksekusi: semuanya hanya diubah menjadi token. Setelah `` di dalam `{...}` setelah diubah menjadi daftar token (sementara), TeX kemudian meninjau kembali setiap token dalam daftar itu dan menguji apakah token tersebut adalah token *karakter* atau sebuah token *perintah* token (menggunakan nilai numerik token). Jika TeX mendeteksi token karakter, ia memodifikasi token itu untuk menyesuaikan huruf karakter (sesuai dengan apakah `\uppercase` atau `\lowercase` sedang diproses). TeX hanya mengabaikan token perintah dan tidak “melihat ke dalam” token perintah untuk mengetahui apa yang mereka wakili atau berisi (mis., makro yang berisi karakter)—token-token itu hanya dilewati: hanya token karakter yang benar-benar diproses/dipengaruhi oleh operasi perubahan huruf. Jadi, misalnya, jika kita menjalankan perintah TeX seperti `\uppercase{abcde}` TeX akan membuat daftar token dari `abcde` yang hanya berisi token karakter: semuanya disesuaikan untuk membuat serangkaian token yang dimodifikasi yang mewakili A, B, C, D, dan E. Token yang dimodifikasi itu dimasukkan kembali ke pemroses input TeX yang menghasilkan `ABCDE` dicetak. Namun, jika kita menyimpan karakter kita *di dalam sebuah makro*—misalnya `\def\mychars{abcde}`—dan mencoba mengubahnya menjadi huruf kapital seperti ini: ```latex \uppercase{\mychars} ``` maka itu akan gagal dan abcde yang akan dicetak—bukan ABCDE seperti yang mungkin Anda harapkan. Jika kemudian kita mencoba menyimpan karakter kita dalam daftar token seperti `\toks0={abcde}` dan melakukan `\uppercase{\the\toks0}` maka, sekali lagi, `\uppercase` akan gagal karena daftar token akan sepenuhnya terdiri dari token-token yang tidak dipengaruhi oleh `\uppercase`. Mengambil contoh makro kita, `\mychars`, setelah TeX mendeteksi `\uppercase` dalam input, TeX mencari makna dari `\uppercase` dan mengeksekusinya, membuat daftar token sementara dari `{\mychars}`. Jelas, daftar token sementara itu hanya berisi satu token yang bukan token karakter melainkan token yang mewakili perintah makro kita `\mychars`: jadi, untuk keperluan mengeksekusi `\uppercase`, token itu diabaikan—`\mychars` tidak mewakili token karakter. Namun, seperti disebutkan di atas, setelah `\uppercase` selesai bekerja, daftar token sementara (yang dibuat oleh aksi `\uppercase`) dimasukkan kembali ke mekanisme pemrosesan input (pemindaian) penuh TeX. Ketika TeX membaca ulang daftar token itu, ia mendeteksi token yang mewakili `\mychars` makro yang dieksekusi (diekspansi) TeX dan menghasilkan serangkaian karakter untuk mencetak abcde—tetap dalam huruf kecil karena mereka “dibungkus” di dalam makro dan karenanya tak terlihat oleh aksi `\uppercase`. Setelah TeX meninjau kembali daftar token sementara yang dibuat untuk `\uppercase{...}` atau `\lowercase{...}`, dan memproses token karakter apa pun, ia kemudian beralih menggunakan daftar token sementara itu sebagai sumber inputnya: mencetak karakter (token karakter yang telah diproses) dan mengeksekusi perintah serta makro. ### Bagaimana ini bisa diperbaiki? Karena `\uppercase{...}` atau `\lowercase{...}` hanya akan bertindak pada token karakter, kita membutuhkan cara untuk “memaksa pembongkaran” karakter yang terkandung dalam makro kita `\mychars` (atau yang terkandung dalam sebuah `\toks` register) sebelum `\uppercase{...}` atau `\lowercase{...}` bertindak padanya. Dengan “membongkar”, yang sebenarnya kita maksud adalah proses TeX untuk *ekspansi*: * mengganti sebuah perintah TeX/LaTeX dengan *urutan* token *yang darinya perintah itu* (*mis., sebuah makro*) *tersusun,* atau * menghasilkan urutan token yang dirancang oleh sebuah perintah untuk *menghasilkan*. Salah satu contoh perintah yang menghasilkan token adalah `\jobname`, yang menghasilkan serangkaian token karakter yang mewakili nama berkas utama TeX yang sedang diproses. #### Keajaiban tingkat lebih rendah: scantoks(..., ...) Di sini kita benar-benar menyelidiki beberapa sudut yang lebih gelap dari cara kerja internal TeX, jadi Anda bisa mengabaikan bagian ini kecuali Anda menikmati detailnya… Setelah TeX mendeteksi `\uppercase` atau `\lowercase` dalam aliran input, ia menjalankan fungsi internal yang disebut `scantoks(..., ...)` yang tugasnya menghasilkan daftar token menggunakan item di antara ‘{’ pembuka dan ‘}’ penutup—seperti dibahas, daftar token itu kemudian diperiksa untuk mendeteksi (lalu menyesuaikan) token karakter apa pun untuk mengubah huruf karakter sesuai kebutuhan. Perhatikan baik-baik bahwa kita merujuk pada `scantoks(..., ...)` sebagai fungsi internal yang tertanam dalam kode sumber mesin TeX—di sini, istilah itu tidak merujuk pada nama suatu control sequence. Sebagai bagian dari pekerjaannya, `scantoks(..., ...)` dapat diarahkan apakah akan mengekspansi atau tidak mengekspansi daftar token yang sedang dibangunnya dan untuk `\uppercase` dan (`\lowercase`) ia tidak mengekspansi token: ia hanya membuatnya dan memasukkannya ke dalam daftar token. Salah satu hal pertama yang `scantoks(..., ...)` harus dilakukan adalah memeriksa adanya ‘{’ pembuka (atau karakter apa pun dengan `\catcode` 1) karena harus memastikan pengguna tidak membuat kesalahan sintaks dan lupa menuliskan ‘{’ pembuka (atau karakter apa pun dengan kode kategori 1)—sebab karakter dengan kode kategori 1 diperlukan untuk menandai awal daftar item yang akan ditokenisasi. Dan inilah triknya: tugas mencari ‘{’ pembuka memicu `scantoks(..., ...)` untuk menjalankan proses ekspansi TeX, yang berarti contoh berikut akan berfungsi: ```latex \let\ob={ \uppercase\ob abcde} \def\obb{\ob} \uppercase\obb xyz} ``` Mengambil contoh `\obb`, sebuah makro, ia dikenali sebagai sebuah *perintah yang dapat diekspansi* dan dengan semestinya diekspansi oleh TeX (melalui `scantoks(..., ...)` fungsi) dalam pencariannya terhadap kurung kurawal pembuka (karakter apa pun dengan kode kategori 1). Ini berarti kita dapat menggunakan “`\expandafter` trik” untuk mencapai tujuan kita “membongkar” karakter dari batas-batas makro kita—yaitu, mengekspansinya. Perhatikan bahwa `\expandafter` juga termasuk kategori sebagai sebuah *perintah yang dapat diekspansi*, jadi TeX mengeksekusinya di sini dan membiarkannya bekerja sebagai bagian dari pencarian ‘{’ pembuka (atau karakter apa pun dengan kode kategori 1). Jadi, jika Anda mendefinisikan: ```latex \toks0={abcde} \def\mychars{abcde} ``` Dan lakukan ini: ```latex \uppercase\expandafter{\mychars} \uppercase\expandafter{\the\toks0} ``` dalam kedua kasus Anda sekarang akan melihat ABCDE dicetak karena `\expandafter` menyebabkan “pembongkaran” (ekspansi) dari `\mychars` dan `\the\toks0`—keduanya menghasilkan `\uppercase` melihat aliran token karakter, yang dapat mereka proses untuk mengubah huruf. ### Contoh 2: \string—lebih banyak daftar token sementara Secara internal, TeX mengklasifikasikan `\string` sebagai salah satu yang disebut perintah “convert”-nya: melakukan operasi “mengubah menjadi teks”. Ini `\string` perintah ini dirancang untuk mengubah sebuah token menjadi versi teks yang dapat dibaca manusia—yaitu, menyusun string karakter yang dapat dibaca manusia tempat token itu awalnya dibuat. Sebagai contoh `\string\hello` membuat daftar token sementara yang berisi karakter \\, h, e, l, l, o — ya, bahkan termasuk ‘\’ di awal. Setelah daftar token itu dibuat, daftar tersebut kemudian dibaca ulang oleh TeX dan teks perintah “`\hello`” disusun—ya, termasuk ‘\’ jika Anda memilih font yang tepat… Anda mungkin bertanya-tanya bagaimana/mengapa TeX dapat menyusun karakter escape ketika biasanya karakter itu digunakan untuk memicu pemindai TeX agar membuat token perintah: mengapa itu tidak dilakukan di sini? Jawabannya berkaitan dengan kode kategori: biasanya, karakter ‘\’ memiliki catcode 0 (karakter escape), tetapi ketika `\string` menghasilkan daftar token internalnya, ia melakukan sesuatu yang sedikit berbeda. Saat membuat daftar token karakter, ia menetapkan kode kategori 12 untuk semua karakter selain karakter spasi yang diberi catcode 10—ingat bahwa token karakter dihitung dari 256 x catcode + nilai ASCII. Jadi, ketika TeX membaca ulang (memasukkan) daftar token sementara yang `\string` dihasilkan dari `\hello`, TeX *tidak melihat karakter escape* karena token untuk ‘\’ dihitung dengan catcode 12 dan bukan 0: TeX hanya memperlakukan ‘\’ sebagai karakter biasa dan menyusunnya. Secara ketat, kita sebaiknya mencatat bahwa TeX sebenarnya tidak menghasilkan token untuk karakter escape ketika mendeteksinya dalam input. Setelah mengenali sebuah karakter dengan kode kategori 0, karakter itu hanya digunakan untuk “memicu” pembuatan token urutan kontrol: setelah memicu TeX untuk melakukan itu, karakter escape telah selesai menjalankan tugasnya dan tidak lagi dipertimbangkan. ### Catatan teknis Sebuah perintah bernama `\showtokens{...}` (diperkenalkan oleh mesin e-TeX) dapat menampilkan daftar token (dalam berkas log). Dari manual e-TeX: > Perintah `\showtokens{}` menampilkan daftar token, dan memungkinkan penampilan kuantitas yang tidak dapat ditampilkan oleh `\show` atau `\showthe`, misalnya: > > ```latex > \showtokens\expandafter{\jobname} > ``` ## Sebagai penutup Pada bagian 291 dari kode sumber TeX (lihat halaman 122 dari [TeX: The Program](https://www.amazon.co.uk/Computers-Typesetting-TeX-Program-TEX/dp/0201134373)) Knuth mendeskripsikan daftar token sebagai berikut: > “Daftar token adalah daftar tertaut tunggal dari simpul satu kata di mem, di mana setiap kata berisi sebuah token dan sebuah tautan. Definisi makro, definisi rutin keluaran, penanda, `\write` teks, dan beberapa hal lain diingat oleh TeX dalam bentuk daftar token, biasanya didahului oleh sebuah simpul dengan jumlah referensi di bidang “token\_ref\_count” miliknya.” Pada pembacaan pertama, ini mungkin tidak mudah dipahami, tetapi, semoga, sekarang sedikit lebih masuk akal. --- # 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/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.