> 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/53-what-is-a-tex-token.md).
# Apa itu "token TeX"?
## Motivasi untuk serangkaian artikel tentang token TeX dan konsep terkait
Motivasi, dan metodologi yang digunakan, untuk menghasilkan serangkaian artikel tentang token TeX dan konsep terkait dibahas dalam artikel ini [Seri Artikel Baru: Token TeX dan Konsep Terkait—Tetapi Mengapa (dan Bagaimana)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Sebagaimana dicatat dalam artikel itu, sepanjang seri ini kami mendasarkan pembahasan dan penjelasan kami pada wawasan yang diperoleh melalui build kustom dari program TeX asli milik Knuth—menggunakannya untuk menghasilkan serangkaian artikel yang bertujuan memberikan deskripsi sederhana dan penjelasan yang mudah diikuti tentang konsep-konsep utama TeX.
## Pendahuluan: apa tujuan kita?
Dalam artikel ini kita mencari tahu dengan tepat apa itu token TeX dengan menelusuri perjalanan pemrosesan dari karakter-karakter dalam file input hingga pembuatan token TeX yang sesungguhnya. Dalam praktiknya, hal ini cukup kompleks sehingga kami menyederhanakan prosesnya hingga inti esensialnya, dengan berusaha membuatnya mudah diikuti dan dipahami sambil tetap menjaga ketepatan teknis.
Kita mulai dengan memperkenalkan beberapa konsep internal penting TeX: *primitif*, *kode perintah* dan *modifikator perintah*. Dari sana, kita menggunakan contoh makro yang sangat sederhana untuk melihat dengan tepat bagaimana TeX memproses perintah `\def` dan token yang dihasilkan yang dibuat TeX untuk merepresentasikan perintah itu.
Kita menutup dengan sekilas melihat bagaimana TeX membuat token untuk merepresentasikan karakter dan bagaimana sebuah karakter `\catcode` benar-benar menjadi melekat secara permanen pada token karakter—sesuatu yang sering disebutkan dalam buku-buku tentang TeX, tetapi di sini kita melihat dengan tepat bagaimana hal itu dicapai.
Grafik berikut menunjukkan perjalanan yang akan kita ringkas—dari teks input ke token TeX:
## Tetapi pertama: primitif dan kode perintah
Setiap mesin TeX (Knuthian TeX, pdfTeX, XeTeX, LuaTeX) memahami sejumlah perintah bawaan: yang disebut *primitif*—perintah penyusun fundamental yang menopang kemampuan pemrograman TeX. Mereka disebut “primitif” karena, tidak seperti makro yang ditentukan pengguna, mereka tidak dibentuk dari perintah lain dan tidak dapat direduksi lagi menjadi instruksi yang lebih sederhana. Untuk TeX milik Knuth ada sekitar 320 primitif—meskipun perlu dicatat bahwa mesin TeX lain seperti pdfTeX, XeTeX, dan LuaTeX semuanya telah menambahkan perintah baru ke program asli Knuth dan akan memuat primitif yang tidak ada dalam perangkat lunak TeX Knuth.
Secara internal, TeX menetapkan sebuah nomor *kode perintah* kepada semua perintah—baik itu makro buatan pengguna maupun primitif bawaan. Kode perintah ini tidak dapat diakses oleh pengguna TeX, kode ini hanyalah bagian dari mekanisme internal pemrosesan TeX, tetapi ada gunanya mengetahuinya untuk pembahasan token TeX selanjutnya.
Kelompok perintah yang memiliki fungsionalitas terkait berbagi kode perintah yang sama. Misalnya, `\def`, `\gdef`, `\edef` dan `\xdef` primitif semuanya digunakan untuk mendefinisikan makro dan berbagi kode perintah 97 (dalam TeX milik Knuth). Jelas, keempat perintah pendefinisi makro itu masing-masing membuat makro dengan cara yang sedikit berbeda; akibatnya, selama pemrosesan, TeX memerlukan cara untuk membedakan di antara mereka.
Sebuah kode perintah saja (misalnya 97) tidak dapat memberi tahu Anda perintah pembuat makro mana yang sedang dipertimbangkan; jadi, seperti yang Anda duga, setiap perintah TeX diberi informasi tambahan yang disebut *pengubah perintah* (lihat contoh di bawah).
### Modifikator perintah: dua jenis
Modifikator perintah terbagi ke dalam dua kategori yang akan kita sebut “Tipe 1” dan “Tipe 2”—TeX tidak menggunakan istilah ini, hanya saja di sini lebih praktis demikian:
* **Tipe 1**: Nilai integer sederhana yang dapat, jika diperlukan, digunakan TeX untuk membedakan perintah yang berbagi kode perintah yang sama.
* **Tipe 2**: Nilai integer yang merupakan lokasi numerik dalam memori TeX yang memberi tahu TeX ke mana ia harus pergi untuk mencari informasi bagi perintah itu. Misalnya, ini berlaku untuk perintah buatan pengguna (makro) di mana modifikator perintah memberi tahu TeX di mana definisi makro disimpan dalam memori.
#### Modifikator perintah Tipe 1 (sebuah contoh)
Seperti disebutkan, dalam TeX milik Knuth keempat perintah primitif untuk mendefinisikan makro: `\def`, `\gdef`, `\edef`, `\xdef` semuanya berbagi kode perintah 97: mereka dibedakan melalui modifikator perintahnya, yang tercantum dalam tabel berikut:
| Perintah | Kode
perintah
| Modifikator
perintah
|
| -------- | ----------------------- | ------------------------------ |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Sebagai contoh kedua, Knuth memutuskan untuk mengimplementasikan perintah `\openout`, `\write`, `\closeout`, `\special`, `\immediate` dan `\setlanguage` sebagai “ekstensi” untuk TeX, semata-mata untuk menunjukkan bagaimana Anda dapat menambahkan primitif baru ke TeX. Dalam kasus ini, perintah-perintah itu sebenarnya tidak benar-benar berbagi “fungsionalitas serupa” kecuali bahwa Knuth memutuskan mengelompokkannya bersama untuk tujuan menjelaskan cara memperluas TeX. Keenam perintah itu diklasifikasikan sebagai “ekstensi” dan dikelompokkan bersama dengan nilai kode perintah 59, tetapi masing-masing memiliki modifikator perintah yang sesuai untuk membedakannya dari yang lain:
| Perintah | Kode
perintah
| Modifikator
perintah
|
| -------------- | ----------------------- | ------------------------------ |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Modifikator perintah Tipe 2 (penjelasan singkat)
Meskipun semua modifikator perintah adalah integer, modifikator Tipe 2 memerlukan sedikit penjelasan tambahan. Modifikator perintah ini dalam TeX disebut “penunjuk” karena mereka menunjuk ke lokasi dalam memori tempat TeX dapat menemukan informasi tambahan untuk perintah itu. Ini mungkin terdengar agak samar, tetapi cara TeX menggunakan penunjuk ini untuk mencari informasi sangat beragam dan penjelasan yang lebih lengkap akan mengalihkan perhatian dari tujuan inti artikel ini. Satu contoh mungkin membantu: makro. Ketika sebuah perintah makro didefinisikan, TeX perlu menyimpan teks pengganti di suatu tempat dalam memori. Seperti akan kita lihat di bawah, makro buatan pengguna memiliki kode perintah antara 111 dan 114 dengan modifikator perintah yang merupakan penunjuk ke memori yang memberi tahu TeX di mana teks penggantinya (definisi makro) disimpan.
### Kode perintah: dapat diekspansi dan tidak dapat diekspansi
Dalam kode sumber TeX milik Knuth, kode perintah bervariasi dari 0 hingga 120—perhatikan bahwa beberapa kode dalam rentang itu murni untuk penggunaan internal khusus dan tidak ditetapkan pada perintah yang dapat diakses oleh pengguna. Perlu dicatat bahwa mesin TeX lain seperti pdfTeX, XeTeX, dan LuaTeX semuanya telah menambahkan perintah baru ke set asli Knuth dan akan memuat lebih banyak primitif, serta kode perintah yang bersesuaian; namun, prinsip-prinsip yang diuraikan di sini merupakan inti bagi semua mesin berbasis TeX yang diturunkan dari kode sumber Knuth.
Kumpulan kode perintah dibagi menjadi dua set utama:
* *perintah yang tidak dapat diekspansi*: memiliki kode perintah kurang dari atau sama dengan 100;
* *perintah yang dapat diekspansi*: memiliki kode perintah lebih besar dari 100, hingga nilai maksimum 120. Rentang 101 hingga 120 mencakup makro buatan pengguna plus perintah seperti `\csname`, `\expandafter` dan `\the`.
Perintah yang tidak dapat diekspansi biasanya melakukan penetapan nilai ke parameter internal atau secara langsung menghasilkan materi yang dapat disusun (typeset). Perintah yang dapat diekspansi biasanya “menyuntikkan” aliran token ke dalam aktivitas pemrosesan TeX yang sedang berlangsung atau mengubah urutan pemrosesan token.
Seperti disebutkan di atas, semua makro (perintah buatan pengguna) diberi kode perintah antara 111 dan 114: nilai yang berbeda mencerminkan apakah makro didefinisikan sebagai `\long`, `\outer`, keduanya, atau tidak keduanya. Berikut contohnya:
| Jenis makro | Contoh | Komentar |
| ----------------------- | ------------------------------ | --------------------------- |
| Bukan long, bukan outer | `\def\ohyeah{....}` | `\ohyeah` kode perintah=111 |
| Long, bukan outer | `\long\def\ohyeah{....}` | `\ohyeah` kode perintah=112 |
| Bukan long, outer | `\outer\def\ohyeah{....}` | `\ohyeah` kode perintah=113 |
| Long outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` kode perintah=114 |
Sebagai pengingat tentang modifikator perintah, ketika sebuah makro didefinisikan TeX akan menyimpan definisi makro di suatu lokasi dalam memori: lokasi itu (sebuah penunjuk) akan menjadi modifikator perintah untuk perintah makro yang akan disimpan dengan kode 111 hingga 114 bergantung pada bagaimana makro itu didefinisikan. Nama yang benar-benar diberikan pada makro buatan pengguna sebenarnya tidak terlalu penting: setelah pemrosesan input, semuanya akan diberi kode perintah yang bervariasi dari 111–114 dan, pada akhirnya, semua perintah yang dibaca TeX dari input Anda, baik itu primitif maupun makro buatan pengguna, pada akhirnya diubah menjadi representasi numerik yang disebut sebuah *token*.
## Perjalanan dari teks input ke token TeX
Pada bagian ini kita akan menggunakan contoh makro yang sangat sederhana untuk melihat dengan tepat bagaimana TeX memproses perintah `\def` untuk membuat token yang merepresentasikan `\def` perintah. Aktivitas pemrosesan TeX secara rinci bisa sangat kompleks sehingga kami tidak menggunakan parameter makro atau delimiter karena itu akan menambah kerumitan dan mengalihkan perhatian dari perjalanan kita.
Misalkan berkas input TeX Anda berisi baris berikut:
```latex
\def\ohyeah{Overleaf is cool!}
```
Saat TeX mulai memproses baris input ini, ia memeriksa `\catcode` dari setiap karakter dan melihat bahwa karakter pertama adalah `\` (karakter pertama dari `\def`). `\` ia mendeteksi (mencarinya di tabel internal) bahwa `\catcode` memiliki *0 yang berarti ia memperkenalkan awal dari sebuah*urutan kontrol. Tentu saja, Anda dapat mendefinisikan ulang karakter apa pun agar memiliki `\catcode` 0, tetapi kita akan mengasumsikan bahwa definisi konvensional plain TeX atau LaTeX digunakan.
Secara ketat, istilah *0 yang berarti ia memperkenalkan awal dari sebuah* memiliki dua subkategori: *kata kontrol* dan *simbol kontrol*:
* *kata kontrol*: sebuah rangkaian karakter dengan `\catcode` huruf (11);
* *simbol kontrol*: sebuah karakter tunggal yang memiliki `\catcode` adalah *berisi nilai data aktual yang disimpan dalam* huruf (11).
Pada titik ini, `\` karakter telah menjalankan tugasnya dan sekarang selesai. Saat mendeteksi sebuah karakter escape, respons TeX adalah mulai membaca semua karakter berikutnya dalam input dengan tujuan mendeteksi control word atau control symbol.
Setelah escape awal `\`, TeX segera mendeteksi `d`: sebuah karakter yang `\catcode` catcode-nya *kata kontrol*11 yang memberi tahu TeX bahwa ia telah menemukan huruf pertama dari sebuah *tidak* telah `\catcode` . Ia terus memindai karakter-karakter berikutnya sampai akhirnya mendeteksi sebuah karakter yang `\`setelah escape awal `\catcode` dengan
Jadi, dalam contoh kita TeX dengan senang hati memindai terus, memeriksa setiap karakter, hingga mencapai `\` sebesar `\ohyeah` awal yang juga memiliki `\catcode` 0. TeX menyadari bahwa ia telah memindai terlalu jauh dan dengan sopan mengembalikan `\` karakter itu`def`) yang dikenalnya sebagai teks dari sebuah control word yang terdiri dari tiga karakter, masing-masing dengan `\catcode` 11 (`d`, `e` dan `f`). Apa yang sekarang perlu dilakukan TeX adalah mencari tahu apa `def` berarti: apa yang harus dilakukannya? Seperti yang mungkin sudah Anda duga, TeX perlu menemukan kode perintah dan pengenal perintah untuk `def` agar ia dapat menentukan apa yang harus dilakukan dengan perintah ini.
## Membuat hash darinya
Setelah mendeteksi sebuah control word (`def`def`def` def dalam contoh kita)
Sebagai bagian dari proses perhitungan hash ini TeX juga akan memeriksa apakah rangkaian karakter dalam control word yang baru terdeteksi itu sudah dikenalnya. Teks yang dapat dibaca manusia dari semua perintah, baik itu primitif maupun makro buatan pengguna, disimpan di dalam area penyimpanan internal yang disebut *string pool*. TeX harus melakukan ini karena mungkin perlu mengeluarkan nama perintah yang dapat dibaca manusia—misalnya, ketika TeX perlu melaporkan kesalahan dan memberikan nama perintah yang bermasalah. Sebagai contoh, makro kita `\def\ohyeah{Overleaf is cool!}` sedang mendefinisikan perintah baru bernama `\ohyeah` dan TeX akan (pada tahap nanti) tidak hanya perlu menghitung nilai hash untuk `ohyeah` (*tanpa* karakter awal `\` tetapi juga menyimpan bentuk string teks (yang dapat dibaca manusia) jika perlu menggunakannya untuk pelaporan kesalahan (atau tugas lain).
Jika Anda ingin rincian lebih lanjut tentang proses penanganan string di TeX, saya telah menulisnya di [situs blog pribadi saya](http://www.readytext.co.uk/?p=3590).
Hasil akhirnya adalah bahwa rangkaian karakter yang mewakili perintah `def` diubah menjadi nilai numerik 1218 (itulah nilai sebenarnya yang dihitung oleh TeX). Pada titik ini karakter-karakter individual `d`, `e` dan `f` tidak lagi menjadi bagian dari cerita utama—mereka sudah dibaca dari input dan telah menjalankan tugasnya: mulai sekarang semuanya tentang integer dan *token*—kita akan segera melihat apa sebenarnya sebuah token! Secara internal, TeX menyebut angka nilai hash ini sebagai *control sequence saat ini* tetapi dalam kode sumber istilah itu disingkat menjadi sebuah variabel yang disebut `curcs`. Kode sumber TeX penuh dengan nama-nama variabel yang sangat pendek, sering kali agak samar.
Tetapi apa yang TeX *sebenarnya lakukan* dengan nilai integer baru 1218 ini? Bagaimana TeX mengetahui bahwa string asli `def`, yang sekarang direpresentasikan oleh integer 1218, sebenarnya merujuk pada instruksi untuk mendefinisikan sebuah makro? Jawabannya adalah bahwa TeX memiliki semacam “lemari arsip” internal tempat ia menyimpan makna dan nilai saat ini dari setiap perintah yang saat ini dikenalnya—baik perintah itu makro buatan pengguna atau primitif bawaan. Alasan TeX bersusah payah mengubah `def` ke dalam nilai hash 1218 (yang sekarang disimpan dalam variabel yang disebut `curcs`) adalah untuk menggunakannya guna mencari *maknanya* sebesar `def`. TeX tentu saja akan mengulangi latihan perhitungan hash ini untuk semua control word yang dideteksinya di input—meskipun tentu saja, control word yang berbeda menghasilkan nilai integer berbeda dari fungsi hashing: itulah seluruh idenya.
“lemari arsip” internal TeX disebut *tabel ekuivalen* dan menjadi topik bagian berikutnya.
### Meninjau tabel ekuivalen
Sebagai ringkasan, mari kita lihat apa yang telah kita pelajari sejauh ini:
* `\` memperkenalkan awal dari sebuah control sequence (baik sebuah *simbol kontrol* atau sebuah *kata kontrol*).
* Jika karakter pertama setelah `\` ia mendeteksi (mencarinya di tabel internal) bahwa `\catcode` 11 (letter) maka itu adalah awal dari sebuah *kata kontrol*.
* Untuk *control words* TeX memindai untuk memeriksa semua karakter input berikutnya yang memiliki `\catcode` 11 dan akan berhenti memindai segera setelah menemukan karakter pertama yang *berisi nilai data aktual yang disimpan dalam* memiliki sebuah `\catcode` 11.
* Rangkaian karakter input (mengikuti `\`) yang memiliki `\catcode` 11 dianggap sebagai sebuah *kata kontrol* yang diketik pengguna: sebuah perintah yang meminta TeX untuk “melakukan sesuatu”.
* Untuk memulai proses “melakukan sesuatu” TeX mengubah rangkaian karakter dalam control word menjadi sebuah integer. Ia melakukannya menggunakan yang disebut fungsi hashing yang menghasilkan sebuah integer.
* Integer (nilai hash yang dihitung) disebut sebagai *control sequence saat ini*, tetapi TeX memberinya nama yang lebih pendek yaitu `curcs`.
* Dalam contoh kita, control word `def` diubah menjadi nilai 1218—yang disimpan dalam variabel bernama `curcs`: yaitu, `curcs=1218`.
TeX sekarang perlu mengetahui apa arti sebenarnya dari *control sequence saat ini* yang baru terdeteksi itu—apa yang dilakukan TeX dengannya?
#### Catatan tentang pengelompokan: kebutuhan untuk menyimpan dan memulihkan informasi
Di sini, kita akan sedikit menyimpang untuk mengingatkan bahwa TeX memiliki kemampuan untuk menyimpan dan memulihkan informasi: yaitu, ia memiliki semacam “memori” bawaan.
Siapa pun yang pernah menulis makro paling sederhana sekalipun harus menyadari mekanisme pengelompokan TeX—misalnya, menggunakan `\def` untuk membuat makro di dalam sebuah grup. Kecuali Anda menerapkan `\global` awalan ke `\def`-makro yang dibuat dan didefinisikan di dalam sebuah grup, nilai atau makna makro tersebut hanya bertahan di dalam grup itu (dan yang berada di bawahnya): definisinya hilang saat grup berakhir. Misalnya, jika Anda mendefinisikan makro sederhana di dalam grup, seperti ini:
```latex
{\def\foo{Hello}}
```
dan mencoba menggunakan `\foo` di luar grup
```latex
{\def\foo{Hello}}% \foo didefinisikan di dalam sebuah grup (catatan: tidak menggunakan \global)
\foo %<--- tidak lagi didefinisikan, sekarang tidak terdefinisi
```
maka kita mendapatkan pesan kesalahan yang akrab: `Urutan kontrol tidak terdefinisi`. `\foo` hanya memiliki makna di dalam grup (dan subgrupnya) tempat ia didefinisikan. Selain itu, ketika Anda mendefinisikan ulang sebuah makro di dalam sebuah grup, nilai baru itu dapat hilang saat grup berakhir dan makna sebelumnya (yang ada di luar grup) dipulihkan.
```latex
\def\foo{Goodbye}
\foo\par% Menghasilkan Goodbye
{\def\foo{Hello}% Didefinisikan ulang di dalam sebuah grup:
{Di dalam grup tingkat ke-2: \foo\par}}% Digunakan di dalam grup tingkat ke-2: \foo menghasilkan Hello
Di luar grup, nilai lama dipulihkan: \foo\par% Menghasilkan Goodbye
```
Tujuan dari contoh-contoh sederhana ini adalah untuk menunjukkan bahwa TeX memiliki semacam “mekanisme penyimpanan” atau “memori” yang menyimpan/memulihkan “makna” perintah—dan tentu saja memang begitu. Kita telah menyinggung ini pada bagian sebelumnya: “mekanisme penyimpanan” atau “lemari arsip” itu adalah sebuah tabel internal besar yang disebut *tabel ekuivalen*. Di situlah TeX menyimpan makna atau nilai saat ini dari semua perintah yang dikenalnya—primitif bawaan dan makro buatan pengguna.
### Tabel ekuivalen: secara analogi
Untuk menjelaskan tabel ekuivalen kita akan melanjutkan dengan analogi. Kita akan terus menggunakan gagasan tentang lemari arsip dengan ribuan laci kecil, masing-masing diberi label dengan integer unik. Pada tahap pemrosesan ini TeX pada dasarnya berkata:
“Oke, saya memiliki nilai integer 1218 yang baru saja saya hitung dan simpan dalam variabel bernama `curcs`. Sekarang saya perlu mengetahui artinya: untuk melakukannya saya akan melihat ke laci nomor 1218 pada lemari arsip saya untuk melihat apa yang tertulis di sana.”
TeX menggunakan 1218 untuk menemukan laci yang tepat dan di sana ia menemukan catatan kecil yang berisi tiga informasi yang namanya adalah yang digunakan dalam kode sumber TeX:
* **`eq_level:`** tingkat pengelompokan saat entri ini didefinisikan (level 1 = didefinisikan secara global). Kita telah melihat efek pengelompokan di atas: di tabel ekuivalen inilah informasi tingkat pengelompokan itu disimpan;
* **`eq_type:`** kode perintah untuk entri ini;
* **`equiv:`** nilai “saat ini” dari entri ini—bisa berupa integer sederhana seperti modifikator perintah yang disebutkan di atas, atau penunjuk ke suatu area dalam memori; misalnya, lokasi memori untuk kumpulan token yang merepresentasikan definisi makro.
Jadi, nilai hash kita 1218 (disimpan dalam variabel `curcs`) pada praktiknya telah digunakan sebagai *kunci* untuk mengakses laci yang berisi makna dan nilai saat ini dari perintah yang awalnya kita ketik sebagai rangkaian huruf `\def`.
Di dalam kode sumber program TeX, `eq_type` untuk perintah apa pun disimpan menggunakan sebuah variabel yang disebut `curcmd` dan nilai `equiv` disimpan dalam variabel yang disebut `curchr`.
### Apa yang dikatakan tabel ekuivalen untuk def?
Seperti disebutkan, nilai hash yang dihitung untuk setiap perintah disimpan dalam variabel yang disebut `curcs`; maka untuk `def` kita memiliki `curcs=1218`. Saat melihat lokasi 1218 di tabel ekuivalen, TeX akan menemukan informasi berikut:
* `curcmd`=97. Ini adalah kode perintah untuk `\def`;
* `curchr`=0. Ini adalah modifikator perintah untuk `\def`.
`\def` adalah perintah TeX primitif (bawaan) dan kecuali telah didefinisikan ulang di suatu tempat, bagian informasi ketiga dan terakhir seharusnya `eq_level=1` yang menunjukkan bahwa makna `\def` didefinisikan secara global dan tidak dibatasi pada tingkat pengelompokan yang lebih rendah. Secara internal, nilai `eq_level` yang melekat pada sebuah perintah memainkan peran yang sangat penting dalam mekanisme pengelompokan TeX tetapi kita tidak akan membahasnya lebih lanjut di sini.
Grafik berikut merangkum penjelasan yang telah kita bahas:
## Token TeX untuk perintah
Setelah menelusuri penjelasan di atas, perhitungan sebenarnya dari token TeX untuk control sequence ternyata sangat sederhana. TeX menggunakan nilai `curcs` (1218) dari fungsi hash untuk membuat sebuah integer sederhana yang disebutnya *token*. Perhitungan untuk menghasilkan token dari nilai `curcs` adalah:
```c
curtok = 4095 + curcs
```
TeX menyimpan nilai token saat ini (yang paling baru dihitung) dalam variabel yang disebut `curtok`.
Jadi, sebagai kesimpulan, token TeX yang merepresentasikan `\def` perintah ini adalah `4095 + 1218 = 5313`. Dan selesai untuk token TeX yang merepresentasikan urutan perintah: token itu hanyalah sebuah bilangan integer yang dihitung dari nilai tabel hash ditambah 4095.
## Token TeX untuk karakter
Ketika TeX perlu membuat token yang merepresentasikan sebuah karakter, ia menggunakan perhitungan yang sama sederhananya berikut:
```c
curtok = 256*catcode + (nilai ASCII dari karakter)
```
Perhatikan bahwa perhitungan yang sedikit berbeda digunakan untuk mesin yang mendukung Unicode seperti LuaTeX.
Sebagai contoh, token TeX yang merepresentasikan karakter spasi dengan `\catcode` 10 dan nilai ASCII 32 adalah:
```c
256*10 + 32 = 2592
```
### Daftar token yang berisi karakter
Ketika Anda membuat daftar token sederhana dengan, misalnya,
```latex
\toks100={Hello}
```
TeX akan membuat daftar token berikut dan menyimpannya di memori untuk digunakan nanti:
* H→ 256 × 11 + 72 = 2888
* e→ 256 × 11 + 101 = 2917
* l→ 256 × 11 +108 = 2924
* l→ 256 × 11 +108 = 2924
* o→256 × 11 + 111 = 2927
Jauh di dalam memori TeX, register token 100 akan memberikan akses ke lokasi penyimpanan “Hello”, yang disimpan sebagai 5 nilai token: 2888, 2917, 2924, 2924, 2927. Perhatikan bahwa token-token ini menggabungkan kode ASCII setiap karakter dan nilai `\catcode`pada saat mereka diubah menjadi token (ditokenisasi). Setelah karakter diubah menjadi token karakter, nilai `\catcode` yang melekat pada mereka bersifat permanen dan disimpan di dalam token untuk digunakan nanti ketika pengguna mengatakan, misalnya, `\the\toks100`.
Seperti disebutkan, token karakter dihitung dari `256*catcode + (nilai ASCII)` sedangkan token control sequence dihitung dari `4095 + curcs` di mana `curcs` adalah nilai hash dari control word (string teks dari perintah yang diketik pengguna) yang dideteksi oleh TeX dalam input. Perlu dicatat bahwa token karakter selalu kurang dari 4095. Karena itu TeX dapat dengan mudah menentukan apakah token tertentu merepresentasikan control sequence (sebuah perintah) atau sebuah karakter dan kemudian mengetahui control sequence atau karakter mana dan `\catcode` pasangan mana yang dikodekan di dalam token itu.
---
# 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/53-what-is-a-tex-token.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.