> 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/topik-lainnya/21-how-tex-macros-actually-work-part-3.md).
# Bagaimana makro TeX sebenarnya bekerja: Bagian 3
[Bagian 1](/latex/id/topik-lainnya/19-how-tex-macros-actually-work-part-1.md) [Bagian 2](/latex/id/topik-lainnya/20-how-tex-macros-actually-work-part-2.md) [Bagian 3](/latex/id/topik-lainnya/21-how-tex-macros-actually-work-part-3.md) [Bagian 4](/latex/id/topik-lainnya/22-how-tex-macros-actually-work-part-4.md) [Bagian 5](/latex/id/topik-lainnya/23-how-tex-macros-actually-work-part-5.md) [Bagian 6](/latex/id/topik-lainnya/24-how-tex-macros-actually-work-part-6.md)
## Waktunya berhenti sejenak!
Sebelum melanjutkan ke bagian berikutnya dari cerita ini, kita perlu melakukan rekap: mengingat kembali ke mana kita akan pergi dan mengumpulkan pikiran kita untuk memastikan semua gagasan kunci sudah pada tempatnya. Sebagai pengingat, contoh yang kita kerjakan didasarkan pada asumsi bahwa TeX telah membaca satu baris teks yang berisi `Hello World \jobname` dan bahwa TeX sedang menata huruf teks ini untuk membangun sebuah paragraf.
### Tujuan akhir
Tujuan kita adalah mengembangkan pemahaman yang lebih baik (lebih mendalam) tentang hakikat makro TeX dan cara kerjanya. Namun, untuk mencapainya kita pertama-tama perlu memahami bagaimana TeX membaca berkas masukan dan memproses karakter-karakter di dalamnya. Berikut ini ringkasan topik yang telah dibahas sejauh ini.
* TeX membaca (memindai) setiap karakter dalam masukan Anda dan, untuk setiap karakter, TeX memiliki dua informasi:
* **kode karakter**: sebuah bilangan bulat yang digunakan untuk mengidentifikasi karakter itu, misalnya saat disimpan dalam berkas masukan .tex;
* **kode kategori**: bilangan bulat lain, internal bagi TeX, yang digunakannya untuk menetapkan makna pada setiap karakter yang dibaca dari masukan.
* Segera setelah sebuah karakter dibaca oleh TeX, kode kategori setiap karakter menjadi *secara permanen* terkait dengan karakter individual itu melalui pembuatan token karakter:
* TeX menggunakan rumus sederhana untuk “mengemas” sebuah kode karakter dan kode kategori yang bersesuaian ke dalam bilangan bulat yang disebut token karakter.
* Anda dapat mengubah makna karakter apa pun yang telah TeX *belum dibaca* dengan menetapkan kode kategori yang berbeda pada karakter mana pun yang perilakunya ingin diubah—yaitu, memodifikasi cara TeX memperlakukan karakter itu.
* Mendefinisikan ulang (memetakan ulang) kode kategori dilakukan menggunakan primitif TeX `\catcode` perintah.
* Ketika TeX melihat kode kategori 0, TeX akan beralih ke mode pemindaian khusus dan mulai mencari sebuah perintah: baik sebuah *kata kontrol* atau sebuah *simbol kontrol*.
Sejauh ini, kita telah melihat proses pemindaian masukan TeX saat ia mengidentifikasi karakter-karakter individual dan menggunakan kode kategori tiap karakter untuk menentukan apa yang harus dilakukan selanjutnya. Beberapa karakter hanyalah item teks biasa untuk penataan huruf (misalnya, kode kategori 11), tetapi kita juga telah melihat karakter spasi (kode kategori 10) dan karakter escape (kode kategori 0). Ada kode kategori lain yang, demi singkatnya, belum kita bahas—seperti kode kategori 1 (“mulai kelompok”, misalnya, `{`), kode kategori 2 (“akhir kelompok”, misalnya, `}`) dan lainnya. Setiap kode kategori memainkan perannya sendiri dalam pemindaian masukan TeX dan pemrosesan selanjutnya oleh proses/algoritma perangkat lunak di dalam TeX.
### Token: tinjauan singkat
Konsep “token” merupakan inti cara kerja TeX: Anda akan melihat “token” disebut atau dirujuk di seluruh buku, artikel, dan komunitas daring terkait TeX, jadi topik ini layak ditinjau secara singkat—Anda dapat menemukan detail lebih lanjut dalam artikel yang telah diterbitkan sebelumnya [Apa itu "token TeX"?](/latex/id/artikel-mendalam/53-what-is-a-tex-token.md)
Kita sudah melihat bahwa TeX mengubah karakter masukan menjadi token dengan menggabungkan kode karakter dan kode kategori menjadi sebuah bilangan bulat komposit tunggal. TeX melakukan hal serupa untuk perintah: dengan menggunakan nama perintah, TeX menghitung sebuah bilangan bulat yang disebut *token perintah* (kita akan membahas ini lebih rinci). Sebagai panduan, Anda dapat menganggap token sebagai cara TeX untuk “mengemas” item-item yang telah dibacanya dari masukan, menjadikannya siap dikirim ke tahap pemrosesan TeX berikutnya. Dengan membungkus semua item (karakter atau perintah) ke dalam satu representasi numerik yang rapi, akan lebih mudah memprosesnya lebih lanjut di rantai berikutnya. Misalnya, ketika TeX ingin menyimpan sebagian masukan Anda untuk digunakan nanti, seperti definisi makro, TeX cukup perlu menyimpan definisi makro Anda, seberapa pun kompleksnya, sebagai serangkaian bilangan bulat, di mana setiap bilangan bulat adalah sebuah token yang merepresentasikan karakter atau perintah yang menjadi bagian dari (terkandung di dalam) definisi makro Anda.
## Jadi, apa selanjutnya?
Pada bagian akhir dari Bagian 2 kita melihat bagaimana karakter escape (kode kategori 0) mengalihkan TeX ke mode pemrosesan khusus tempat ia mencari nama sebuah perintah. Dalam contoh kita, TeX mendeteksi rangkaian karakter `jobname` dan kita mengakhiri Bagian 2 pada titik ketika TeX akan “melakukan sesuatu” dengan rangkaian karakter itu (nama sebuah perintah). Pada bagian ini kita akan melihat, secara rinci, apa yang dilakukan TeX selanjutnya.
Setelah TeX mengidentifikasi bahwa urutan karakter tertentu dalam berkas masukan Anda mewakili nama sebuah perintah (di sini, `jobname`) TeX mungkin, tergantung pada apa yang sedang dilakukannya, perlu mengeksekusi perintah itu. Kita mengatakan “mungkin perlu” karena ada kalanya TeX tidak akan langsung mencoba mengeksekusi sebuah perintah: misalnya, ketika ia sedang mendefinisikan sebuah makro (TeX sedang membangun daftar token)—topik yang akan kita bahas nanti. Namun, kita akan terus mengikuti contoh kita di mana TeX sedang menata sebuah paragraf dan *akan*, dalam situasi ini, perlu mengeksekusi `\jobname`.
### Dari rangkaian karakter menjadi menjalankan perintah: bagaimana?
Pertama, mari kita tinjau kembali Grafik 5b dari Bagian 2, di mana TeX telah mengidentifikasi bahwa rangkaian karakter tertentu di dalam masukan merupakan nama sebuah perintah: `jobname`. Grafik 5b menunjukkan bahwa TeX harus “Memeriksa tabel internal...”. Apa arti *sebenarnya*?
Deskripsi lain yang lebih rinci tentang bagaimana TeX “Memeriksa tabel internal” untuk beralih dari memiliki rangkaian karakter (misalnya, `jobname`) hingga menentukan secara tepat apa perintah itu, dan apa maknanya, dapat ditemukan dalam artikel sebelumnya [Apa itu "token TeX"?](/latex/id/artikel-mendalam/53-what-is-a-tex-token.md) Di sini, kita akan merangkum gagasan-gagasan kunci sambil berusaha menghindari pengulangan yang berlebihan.
Mari mulai dengan sebuah analogi. Misalkan Anda sedang membaca buku dan menemukan kata yang tidak dikenal: apa yang Anda lakukan? Saat ini, hampir pasti “mencari di Google”, tetapi mari kita asumsikan Anda lebih suka metode yang lebih lama: Anda mengambil kamus yang mencantumkan kata-kata dan memberikan maknanya. TeX memiliki mekanisme yang analog: sebuah “kamus” internal yang mencantumkan semua perintah yang saat ini dikenal TeX—serta “makna” dari perintah-perintah itu. Dengan “makna” yang dimaksud adalah jenis perintah apa itu: apa yang dilakukannya, plus informasi lain apa pun yang mungkin dibutuhkan TeX untuk menjalankan perintah itu. Perlu dicatat juga bahwa istilah “perintah” mencakup makro TeX/LaTeX apa pun yang ditulis oleh pengguna/programmer TeX dan [ratusan perintah primitif bawaan](/latex/id/topik-lainnya/46-tex-primitives-listed-by-tex-engine.md).
Melanjutkan analogi kamus kita. Ketika, sebagai pembaca manusia, kita perlu mencari makna sebuah kata, kita akan mencari di kamus menggunakan daftar alfabet kata yang disediakan kamus—tetapi, tentu saja, TeX tidak bekerja persis seperti itu. Kembali ke `jobname` contoh asli kita, bagaimana TeX menemukan, di dalam “kamus”-nya, “makna” dari `jobname`—dan apa sebenarnya yang disediakan “makna” itu bagi TeX?
Alih-alih menyediakan “daftar alfabet” internal dari semua perintah yang diketahui TeX, TeX melakukan sesuatu yang sedikit berbeda. TeX mengubah seluruh urutan karakter—yang terdapat dalam nama sebuah perintah—menjadi sebuah bilangan bulat tunggal, yang akan digunakan untuk mengidentifikasi (merepresentasikan) perintah itu. Secara internal, TeX menyimpan sebuah “kamus” besar dari semua perintah yang diketahui ke dalamnya ia menyimpan/merekam *bilangan bulat* yang dihitung dari nama perintah—perhatikan bahwa kamus itu tidak menyimpan nama perintah yang sebenarnya sebagai urutan huruf (disebut *string*). TeX menggunakan kamus itu untuk semua perintah bawaannya (primitif) *dan* kamus itu akan digunakan untuk menyimpan rincian dari makro (perintah) apa pun yang dibuat oleh pengguna: nama makro Anda diubah menjadi sebuah bilangan bulat dan bilangan bulat itu “didaftarkan” di dalam kamus TeX.
Setiap kali TeX mendeteksi sebuah perintah yang digunakan dalam masukan Anda, dan perlu mengetahui sesuatu tentang perintah itu, TeX mengubah rangkaian karakter pada nama perintah menjadi bilangan bulat yang “ekuivalen” dan menggunakan bilangan bulat itu untuk mencari perintah tersebut di dalam “kamus besar”-nya. Bagi para programmer, mungkin menarik untuk diketahui bahwa TeX menggunakan suatu bentuk [fungsi hash](https://en.wikipedia.org/wiki/Hash_function) fungsi hash
### Grafik 6: Dari karakter ke makna perintah
Grafik berikut menunjukkan perjalanan sebuah perintah saat TeX mengubah rangkaian karakter menjadi bilangan bulat yang ekuivalen, yang disebut **curcs**, dan menggunakan bilangan bulat itu untuk mencari makna perintah di “kamus besar” TeX. Hasil pencarian itu adalah dua informasi: dua bilangan bulat, yang disebut **curcmd** dan **curchr**, yang dapat digunakan TeX untuk menentukan secara tepat apa yang dilakukan perintah itu dan bagaimana kemudian mengeksekusinya.
Secara internal, TeX mempertahankan sebuah variabel yang disebut **curcs** (**cur**rent **c**ontrol **s**urutan) yang digunakan untuk menyimpan nilai bilangan bulat dari perintah yang sedang dikerjakan TeX—yaitu, **curcs** menyimpan bilangan bulat yang dihitung dari nama perintah. Itu belum seluruh ceritanya karena ada satu detail lagi: jika TeX baru saja membaca/memproses sebuah karakter, bukan perintah, maka TeX akan menetapkan **curcs** bernilai 0, untuk mengingat bahwa hal terakhir yang dibaca adalah sebuah karakter, bukan perintah.
### Apa arti perintah bagi TeX
Jika kita melihat kumpulan [perintah bawaan yang disediakan oleh mesin TeX](/latex/id/topik-lainnya/46-tex-primitives-listed-by-tex-engine.md) kita dapat melihat bahwa beberapa perintah tersebut sangat terkait: mereka melakukan tugas yang serupa; misalnya, ada 4 perintah primitif yang digunakan semua mesin TeX untuk mendefinisikan (membuat) makro: `\def`, `\gdef`, `\edef`, `\xdef`. Keempat perintah itu semuanya mendefinisikan makro tetapi, tentu saja, masing-masing melakukannya sedikit berbeda. Jika kita memikirkannya dari sudut pandang pemrograman: di sini ada 4 perintah pendefinisian makro yang, secara umum, melakukan hal yang sama tetapi kita perlu memilih di antara mereka untuk menyesuaikan perilaku masing-masing.
Untuk mengatasi hal ini, TeX memberikan dua nilai pada setiap perintah dan kedua nilai itulah yang dipahami TeX sebagai “makna” sebuah perintah (peran/apa yang dilakukannya)—kedua nilai itu bersifat internal bagi TeX, sangat dalam di dalam perangkat lunak, dan merupakan bagian dari “mesin dalam” yang tidak dapat diakses oleh pengguna. Setiap perintah TeX, baik primitif bawaan maupun perintah yang ditentukan pengguna, diberi dua nilai yang, bagi TeX, mendefinisikan/mengklasifikasikan perilakunya—apa artinya bagi TeX. Ketika TeX menggunakan “kamus besarnya” untuk mencari sebuah perintah, TeX akan menemukan dua informasi penting ini:
* **kode perintah**: semacam “klasifikasi umum” yang menunjukkan “jenis” perintah itu—seperti perintah “pendefinisian makro” (salah satu dari `\def`, `\gdef`, `\edef`, `\xdef`); perintah “pembuatan kotak” (salah satu dari `\hbox`, `\vbox` atau `\vcenter`) dan seterusnya untuk ratusan perintah yang didukung mesin TeX. Makro (perintah yang ditentukan pengguna) juga diberi kode perintah.
* **pengubah perintah**: Ini adalah informasi tambahan yang memberikan TeX informasi spesifik tentang sebuah perintah. Makro (perintah yang ditentukan pengguna) juga diberi pengubah perintah—meskipun, pada makro, pengubah perintah berperan sedikit berbeda dibandingkan pada primitif (pada makro, pengubah perintah menunjukkan di mana definisi makro disimpan dalam memori).
Jika digabungkan, kode perintah dan pengubah perintah secara unik mengidentifikasi setiap perintah. Berikut adalah kode perintah dan pengubah perintah untuk perintah-perintah pendefinisian makro seperti yang digunakan oleh perangkat lunak TeX asli Knuth—perhatikan bahwa mesin TeX lain mungkin menggunakan nilai yang berbeda tetapi mengikuti prinsip yang persis sama:
| | | |
| ------------ | --------------------------------------------------------- | ------------------------------------------------------------- |
| **Perintah** | Perintah
kode
| Perintah
pengubah
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Rekap: memahami semua variabel/nilai ini
Pada titik ini kita dibanjiri banyak informasi tentang nilai, variabel, nilai perintah, dan segala macam rincian—hal itu bisa dengan cepat menjadi membingungkan, jadi mari kita tinjau apa yang kita ketahui. Ketika TeX membaca sesuatu dari masukan Anda, itu bisa berupa karakter atau perintah. Setiap kali TeX membaca sesuatu dari masukan, TeX perlu menyimpan informasi tentang apa yang baru saja dibaca (dipindai):
* Untuk **karakter**: ia perlu mencatat kode karakter dan kode kategori. Ia juga perlu membuat dan menyimpan nilai token yang dihitung TeX menggunakan nilai-nilai tersebut.
* Untuk **perintah**: TeX perlu mengetahui padanan numeriknya, **curcs**, yang dihitung dari nama perintah. TeX juga mungkin perlu menyimpan “makna” yang diperolehnya dengan mencari perintah itu di “kamus” TeX: kode perintah dan pengubah perintah. Selain itu TeX juga perlu menghitung nilai token yang merepresentasikan perintah ini.
Ya, membingungkan: banyak variabel dan gagasan token yang beredar, jadi mari kita coba memahaminya.
Secara internal, TeX menggunakan empat variabel global untuk menyimpan informasi tentang item terbaru yang telah TeX baca (atau yang sedang “dikerjakan”)—kita tidak akan membahas variabel-variabel itu secara rinci, tetapi mengetahui keberadaannya membantu memberikan sedikit latar belakang untuk memahami apa yang sebenarnya terjadi:
* **curcmd**: (perintah saat ini) sebuah variabel bilangan bulat. Variabel ini digunakan untuk menyimpan *perintah saat ini* nilai untuk perintah yang sedang diproses *atau* ia menyimpan *kode kategori* dari karakter yang sedang diproses;
* **curchr**: (karakter saat ini) sebuah variabel bilangan bulat, tetapi apa yang disimpannya bergantung pada apa yang baru saja dibaca TeX dari masukan:
* **karakter**: Jika item yang paling baru dibaca adalah sebuah karakter, **curchr** menyimpan saat ini *kode karakter*.
* **perintah**: Jika item yang paling baru dibaca adalah sebuah perintah, **curchr** menyimpan *pengubah perintah*: informasi tambahan yang digunakan TeX untuk mendukung/menjelaskan **curcmd**—karena, seperti yang kita lihat di atas, beberapa perintah berbagi nilai yang sama dari **curcmd**
* **curcs**: (urutan kontrol saat ini) sebuah variabel bilangan bulat yang menyimpan nilai yang dihitung dari rangkaian karakter dalam nama perintah. **curcs** = 0 jika item terakhir yang dibaca adalah sebuah karakter individual dan bukan nama urutan kontrol (nama perintah);
* **curtok**: (token saat ini) sebuah variabel bilangan bulat yang menyimpan nilai token saat ini—yang bisa berupa token perintah atau token karakter.
Berikut informasi di atas ditampilkan sebagai tabel:
| | | |
| ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Variabel global yang digunakan di dalam TeX:** | **Saat TeX memindai sebuah karakter:** | **Saat TeX memindai sebuah perintah:** |
| **curcmd** | Menyimpan kode kategori dari karakter saat ini | Menyimpan *kode perintah*—yang mengidentifikasi “jenis” perintah saat ini |
| **curchr** | Menyimpan kode karakter dari karakter saat ini | Menyimpan data tambahan (disebut *pengubah perintah*) yang memberikan informasi tambahan tentang perintah saat ini |
| **curcs** | 0 | Sebuah bilangan bulat positif tak nol yang dihitung (melalui fungsi hash) menggunakan rangkaian karakter yang terdapat dalam nama perintah. Ini digunakan untuk mengakses “kamus” TeX guna mencari makna saat ini dari sebuah perintah—untuk mengambil kode perintah dan pengubah perintahnya. |
| **curtok** | Untuk mesin TeX 8-bit, sebuah *token karakter* dihitung menggunakan rumus: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ di mana $$\text{curcmd}$$ adalah kode kategori karakter dan $$\text{curchr}$$ adalah kode karakter | Untuk mesin TeX 8-bit, sebuah *token perintah* dihitung menggunakan rumus: $$\text{curtok}=4095 + \text{curcs}$$ |
### Catatan lebih lanjut tentang token saat ini
Untuk karakter, nilai token maksimum yang mungkin diperoleh menggunakan kode kategori terbesar (15) dan kode karakter terbesar yang, untuk mesin TeX 8-bit, adalah 255. Secara teori (untuk mesin TeX 8-bit), nilai maksimum token karakter, $$\text{curtok}\_{\text{max}}$$, adalah:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Kita mencatat “secara teori” karena kode kategori 15 digunakan untuk merepresentasikan “karakter tidak valid” yang menyebabkan TeX menghasilkan kesalahan: karakter tidak valid tidak akan pernah lolos dari proses pemindaian masukan TeX dan karenanya tidak akan pernah menjadi token karakter.
Untuk perintah, token saat ini ($$\text{curtok}$$) dihitung dari $$\text{curtok}=4095 + \text{curcs}$$ tetapi untuk perintah $$\text{curcs}$$ adalah *selalu* bernilai tak nol, sehingga TeX dapat dengan mudah menentukan apa yang direpresentasikan sebuah token:
* Jika $$\text{curtok} > 4095$$ maka itu adalah token perintah;
* Jika $$\text{curtok} < 4095$$ itu adalah token karakter.
Pada dasarnya, TeX menggunakan token, sebuah nilai bilangan bulat sederhana, untuk “mengemas” semua informasi yang perlu diketahuinya tentang item yang dibaca dari masukan.
## Bagian 4
Pada Bagian 4 kita mengeksplorasi berbagai contoh makro untuk menunjukkan peran dan tujuan dari `` bagian sebuah makro untuk bertindak sebagai “templat token” yang dapat dibentuk melalui penggunaan token pembatas.
[Bagian 1](/latex/id/topik-lainnya/19-how-tex-macros-actually-work-part-1.md) [Bagian 2](/latex/id/topik-lainnya/20-how-tex-macros-actually-work-part-2.md) [Bagian 3](/latex/id/topik-lainnya/21-how-tex-macros-actually-work-part-3.md) [Bagian 4](/latex/id/topik-lainnya/22-how-tex-macros-actually-work-part-4.md) [Bagian 5](/latex/id/topik-lainnya/23-how-tex-macros-actually-work-part-5.md) [Bagian 6](/latex/id/topik-lainnya/24-how-tex-macros-actually-work-part-6.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/topik-lainnya/21-how-tex-macros-actually-work-part-3.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.