> 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/24-how-tex-macros-actually-work-part-6.md).

# Bagaimana makro TeX sebenarnya bekerja: Bagian 6

[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)

## Pendahuluan dan gambaran umum: Kisah sejauh ini

Pada 5 bagian sebelumnya dari seri ini kita telah melihat:

* bagaimana TeX membaca karakter di dalam berkas input dan menggunakan kode kategori untuk mengenali berbagai “kelas” karakter dan kemudian mengonversinya menjadi token karakter dan token perintah;
* bahwa sebuah makro, pada dasarnya, terdiri dari empat bagian:

```
<primitif makro TeX><nama makro><teks parameter>{<teks pengganti>}
```

di mana:

* `<primitif makro TeX>` = salah satu dari `\def`, `\edef`, `\gdef` atau `\xdef`;
* `<nama makro>`=nama makro Anda, seperti `\foo`;
* `<teks parameter>` dapat “null” (tidak ada) atau dapat berupa sebuah string token pemisah dan token parameter makro;
* `<teks pengganti>` adalah isi sebenarnya dari makro Anda: bagian yang “dijalankan” (diperluas) ketika Anda memanggil makro.
* bagaimana `<teks parameter>` bagian tersebut dapat berisi berbagai token dan TeX menggunakan bagian ini sebagai “templat token” untuk mencocokkan pemanggilan makro dengan definisi aslinya dan menentukan argumen yang digunakan dengan makro—serta bagaimana TeX mengharapkan penggunaan makro Anda cocok dengan definisi aslinya;
* bahwa, di dalam TeX, definisi makro disimpan sebagai urutan token berkelanjutan yang mewakili `<teks parameter>` dan `<teks pengganti>` bagian-bagian tersebut.

Ketika Anda menggunakan sebuah perintah makro TeX akan terlebih dahulu memeriksa apakah ia menerima parameter. Jika ya, TeX kemudian harus mengidentifikasi argumen yang sebenarnya *argumen* yang digunakan dalam pemanggilan makro Anda. TeX harus menguji pemanggilan makro Anda terhadap definisi “templat token” yang telah disimpannya di memori. Secara khusus, TeX menggunakan definisi internal (tersimpan) dari `<teks parameter>` bagian sebagai templat untuk memilih *token* yang merupakan argumen sebenarnya, dan mana yang *token* hanya berfungsi sebagai pemisah.

## Makna perluasan makro

Sekarang, akhirnya, kita siap beralih ke topik terpenting: bagaimana TeX memproses argumen makro dan benar-benar menjalankan makro: suatu proses yang oleh TeX disebut sebagai *perluasan makro*.

### Tetapi pertama, sebuah contoh singkat: sesuatu yang aneh?

Untuk “menggambarkan situasi” guna menjelaskan mekanisme dengan mana TeX memproses makro dan argumennya, kita akan menggunakan contoh singkat untuk menunjukkan hal-hal yang perlu kita pertimbangkan.

#### Argumen pertama-tama dikonversi menjadi token

Contoh berikut didasarkan pada salah satu yang dibahas pada halaman 114–5 dari [The Advanced TeXbook](https://www.amazon.co.uk/Advanced-Texbook-David-Salomon/dp/0387945563) yang ditulis oleh David Salomon. Ini dipilih karena dengan baik merangkum ide-ide utama dalam sebuah makro TeX yang sangat singkat.

Dalam operasi TeX/LaTeX normal, tanda `$` memiliki kode kategori 3 (“math shift”) yang mengalihkan TeX masuk/keluar dari mode matematika sebaris (`$...$`) atau mode matematika tampilan (`$$...$$`)—tentu saja, LaTeX menggunakan `\(..\)` dan `\[..\]` untuk tujuan yang sama.

Misalkan kita ingin sebuah makro yang mengubah kode kategori dari sebuah `$` tanda menjadi, misalnya, 11 sehingga kita dapat menatanya seperti karakter biasa. Kita dapat menggunakan perintah primitif TeX `\catcode` dan percobaan pertama kita atas makro seperti itu, `\docat`, mungkin adalah

```
\def\docat #1{\catcode`\$=11 #1}
```

Namun, ketika kita mencoba menggunakannya, seperti ini

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
I paid \docat{$90} for that book.
\end{document}
```

kita mengharapkan TeX menata `I paid $90 for that book.` tetapi gagal dengan pesan kesalahan:

```
! Missing $ inserted.
<inserted text>
                $
<untuk dibaca lagi>
                   \par
l.7
```

Dari kesalahan tersebut tampaknya `$` yang digunakan dalam argumen makro kita masih memicu TeX untuk menata matematika; jelas, TeX *tidak* mengubah kode kategori dari `$` yang digunakan dalam argumen makro kita (`$90`). Pertanyaannya adalah *mengapa* mengapa TeX tidak mengubah kode kategori dari `$` menjadi 11 dan menatanya sebagai karakter biasa? Jawaban singkatnya adalah bahwa TeX pertama-tama mengonversi argumen makro menjadi token **sebelum** lalu memasukkannya ke dalam daftar token dari `<teks pengganti>`—tetapi kita akan melihat mekanisme yang mendasarinya dengan jauh lebih rinci.

Yang perlu kita ingat adalah bahwa gagasan kita tentang TeX menggunakan teks/karakter hanya relevan untuk isi berkas yang sedang dibaca TeX: begitu TeX telah membaca karakter apa pun, kita berada di dunia *token*. Pemanggilan makro TeX bekerja dengan *token*, bukan *representasi tertulis/teks* dari perintah TeX/LaTeX—ini akan menjadi lebih jelas saat kita membahas contoh ini.

Awalnya, kita mungkin mengira bahwa penggunaan kita atas `\docat` makro dalam `I paid \docat{$90} for that book.` sama dengan langsung menulis kode TeX (atau LaTeX) yang setara—seperti berikut ini, yang *tidak* akan berhasil:

```
\begin{document}
I paid \catcode`\$=11 $90 for that book.
\end{document}
```

![Beberapa kode TeX yang berjalan di Overleaf](/files/dc29ded6e9aa22985a46ee2216cb2402f2b37fc7)

Namun, seperti yang kita lihat di atas, cara TeX memproses argumen makro menghasilkan hasil (`! Missing $ inserted.`) yang sangat berbeda dari menuliskan kode TeX: sekarang kita akan menjelajahi *mengapa* yang terjadi.

### Makro dan argumen sebagai daftar token

Untuk memahami sepenuhnya perilaku `\docat` makro, dan argumennya (`$90`), dan mengapa ia gagal, kita perlu memvisualisasikan lagi definisi `\docat` makro dan argumen apa pun yang digunakan (ketika \docat dipanggil) sebagai *daftar token*, bukan sebagai urutan karakter.

Saat TeX memindai teks input Anda, ia akan mengenali `\docat` sebagai perintah makro; setelah itu ia memeriksa apakah ia menerima parameter—bagaimana TeX melakukan itu dijelaskan pada bagian berikut bagi pembaca yang tertarik pada detail yang lebih halus.

#### Bagi mereka yang menyukai detail...

Setelah makro dipanggil, TeX memeriksa apakah token pertama sekali (di dalam daftar token definisi tersimpan makro) adalah **pencocokan akhir** token: jika demikian, TeX dapat yakin bahwa makro tersebut tidak menerima parameter apa pun.

**Sebuah contoh**

Diagram daftar node berikut membandingkan daftar token untuk dua makro:

* `\def\foo A#1B{#1}`: ini memiliki `<teks parameter>` sebesar `A#1B`, sehingga **pencocokan akhir** tokennya adalah **berisi nilai data aktual yang disimpan dalam** token pertama jadi TeX akan melanjutkan untuk mencari parameter;
* `\def\foo{X}`: ini tidak memiliki sebuah `<teks parameter>` bagian, sehingga **pencocokan akhir** token adalah yang pertama dalam daftar token dan TeX tahu untuk tidak mencari parameter apa pun.

![Bagaimana TeX memeriksa apakah sebuah makro menerima parameter](/files/61141ce1589b3cde06b96eeeaed549103b631fa3)

## Menuju “Grand Finale”: perluasan

Mari kita ingat kembali pertanyaannya: mengapa makro berikut tidak berfungsi; yaitu, mengapa TeX tidak mengubah kode kategori dari tanda `$` yang digunakan dalam argumen `\docat` makro, seperti `\docat{$90}`?

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
I paid \docat{$90} for that book.
\end{document}
```

Seperti dijelaskan di atas, ketika TeX memindai input Anda dan mengenali sebuah perintah makro—pada saat TeX akan mengeksekusinya—TeX terlebih dahulu memeriksa apakah makro tersebut menerima parameter. Jika ya, TeX perlu memindai lebih lanjut berkas input untuk mengidentifikasi argumen yang sebenarnya *argumen* yang disediakan pengguna untuk pemanggilan makro tertentu ini: TeX harus melakukan ini **sebelum** sebelum dapat memanggil kode makro yang sebenarnya. Jelas, TeX perlu menentukan data yang ingin diberikan pengguna kepada makro.

Untuk mengidentifikasi argumen yang ada dalam input (pemanggilan makro oleh pengguna), TeX akan dipandu oleh definisi makro yang tersimpan secara internal: khususnya, `<teks parameter>` bagian dari definisi makro tersimpan (daftar token)—yang menyediakan semacam “templat token”. Dengan menggunakan “templat token” itu TeX harus menentukan mana yang *token* dalam pemanggilan makro pengguna hanyalah *pemisah* (pada dasarnya “tanda baca”) dan mana yang *token* menjadi bagian dari sebuah *argumen*. Saat TeX menemukan sebuah **parameter pencocokan** token dalam definisi makro tersimpan `<teks parameter>` bagian (“templat token”) bahwa ia tahu untuk mulai membentuk sebuah *daftar token* untuk argumen tersebut.

Begitu TeX mengenali perlunya mengidentifikasi argumen pengguna, TeX akan memindai input untuk menghasilkan token dan memeriksanya dengan sangat hati-hati, token demi token, terhadap definisi makro yang tersimpan. TeX terus mengumpulkan token untuk sebuah argumen sampai ia mendeteksi token yang sebenarnya merupakan pemisah, atau jika ia mendeteksi **pencocokan akhir** token: dalam kedua kasus, TeX kemudian tahu bahwa sudah waktunya berhenti mencari token yang membentuk bagian dari argumen tersebut.

### Mengapa makro \docat gagal

Seperti dicatat, *sebelum* TeX sebenarnya dapat memanggil sebuah makro jika ia harus mengidentifikasi dan menyiapkan argumen apa pun yang akan digunakan dengan makro tersebut. Namun, untuk mengidentifikasi argumen(-argumen) itu, siap untuk dimasukkan ke dalam makro, TeX harus menghasilkan setiap argumen sebagai sebuah *daftar token*: dan itulah alasan untuk `\docat`kegagalan

Dalam contoh kita, kita memberikan `\docat` kepada `$90` tetapi argumen itu pertama-tama *dikonversi menjadi daftar token* saat TeX memindai pemanggilan makro—argumen tersebut dikonversi menjadi token *sebelum* sebelum makro benar-benar dipanggil. Di sini, untuk argumen `$90`, TeX akan menghasilkan tiga token karakter: satu token untuk masing-masing `$`, `9` dan `0`.

Grafik berikut menunjukkan daftar token yang dihasilkan untuk argumen `$90`, sebelum dimasukkan ke dalam tubuh `\docat` makro:

![Daftar token TeX yang dihasilkan untuk sebuah argumen makro](/files/ecc7496144688f7f174a76dfad1ce206e16aab1e)

Dalam grafik di atas kita dapat dengan jelas melihat bahwa daftar token argumen memuat `$` sebagai token karakter berdasarkan kode kategori 3.

Seperti yang kita lihat dalam Bagian 1 hingga 3, token karakter dibuat menggunakan nilai kode kategori *yang berlaku pada saat karakter dibaca*—yaitu, pada saat daftar token argumen dibuat (diubah menjadi token). Saat argumen sedang ditokenisasi, `\docat` makro belum dieksekusi sehingga perubahan kode kategori yang kita letakkan dalam pemanggilan makro (``\catcode`\$=11``) *tidak* tidak memengaruhi kode kategori yang digunakan untuk menghasilkan token argumen.

Setelah TeX menghasilkan daftar token yang mewakili argumen dari `$90`, ketiga token karakter itu dimasukkan ke dalam makro yang sebenarnya `<teks pengganti>`. Namun, itu menghasilkan `$` yang dimasukkan sebagai sebuah *token karakter* yang dibuat menggunakan kode kategori 3: “math on” dan kita telah melihat bahwa setelah token karakter terbentuk, kode kategori yang melekat padanya bersifat permanen. Token `$` adalah *berisi nilai data aktual yang disimpan dalam* yang dimasukkan ke dalam makro *bukan sebagai karakter*, melainkan sebagai sebuah *token karakter* berdasarkan `$` yang memiliki kode kategori 3.

### Menjalankan \docat: perluasan makro

TeX menyebut proses “mengeksekusi” sebuah makro sebagai *perluasan makro*; sebuah istilah yang, menurut penulis ini, agak membingungkan tetapi itu adalah terminologi yang diterima sehingga kita akan terus menggunakannya.

#### Makna sebenarnya dari perluasan makro

Setelah TeX mendeteksi `\docat` perintah dalam input pengguna, ia memindai argumen dan menghasilkan daftar token untuk argumennya(`$90`). Untuk mengeksekusi (memperluas) makro, TeX mengalihkan pandangannya dari berkas input pengguna dan mulai membaca token yang terdapat `\docat`’s `<teks pengganti>` daftar token yang tersimpan di memori TeX.

Saat TeX memproses `\docat`definisi`**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**#1**`).

Grafik berikut menunjukkan proses memperluas `\docat` makro: TeX berhenti mengambil token dari berkas input dan mulai membaca token dari `<teks pengganti>` bagian `\docat` definisi makro yang tersimpan di memori. TeX kemudian menjalankan token-token yang telah disiapkan ini sampai ia melihat sebuah **parameter keluaran** token yang memerintahkan TeX untuk membaca (“menyuntikkan”) dan “mengeksekusi” token argumen pada titik ini. Dalam contoh kita, itu adalah tiga token karakter yang mewakili `$90` dan itu menghasilkan kesalahan karena token karakter yang telah disiapkan sebelumnya untuk `$` memiliki kode kategori 3. Karena kita berurusan dengan token karakter, bukan karakter, `$` tidak terpengaruh oleh perubahan kode kategori sebelumnya yang disebabkan oleh token dalam ``\catcode`\$=11``.

![Menunjukkan proses memperluas makro \docat](/files/3056a11152c7093d972366ae5de4b15583df415c)

Setelah TeX memproses token yang mewakili ``\catcode`\$=11``, perubahan kode kategori untuk `$` sekarang berlaku. TeX kemudian menemui “token khusus” yang disebut **parameter keluaran** yang memberi tahu TeX untuk **menyisipkan** daftar token untuk argumen. Namun, daftar token itu terdiri dari tiga token karakter *token*, yang pertama adalah token untuk sebuah `$` dengan kode kategori 3 (“math on”) yang ditetapkan kepadanya: perubahan kode kategori sebelumnya di dalam makro tidak dapat memengaruhi token karakter ini sehingga TeX memperlakukan token itu sebagai sinyal untuk memulai pemrosesan matematika yang menyebabkan makro gagal.

### Dapatkah makro \docat diperbaiki?

Dari pembahasan di atas, jelas bahwa karakter apa pun yang muncul dalam argumen makro ditokenisasi menggunakan kode kategori yang berlaku pada saat tokenisasi berlangsung—yang, dalam contoh kita, adalah *selalu* sebelum `<teks pengganti>` dari `\docat` makro benar-benar dieksekusi. Jadi, bagaimana kita dapat memastikan bahwa argumen sebuah makro mengalami perubahan kode kategori?

Salah satu caranya adalah mengubah `\docat` agar menjadi makro tanpa parameter yang hanya melakukan perubahan kode kategori—ia tidak memiliki argumen apa pun untuk ditokenisasi. Kemudian kita menggunakan makro kedua, `\getarg`, yang menerima satu parameter, dan mengatur agar makro itu memiliki argumennya ditokenisasi ketika kode kategori yang sesuai untuk `$` sedang berlaku.

```
\begin{document}
\def\docat{\catcode`\$=11 \getarg} % Tidak ada parameter, memanggil makro kedua \getarg
\def\getarg#1{#1} %1 parameter yang argumennya akan ditokenisasi
Sekarang Anda dapat menjalankannya seperti ini dan itu akan berhasil:

I paid \docat{$90} for that book.
\end{document}
```

Ketika kita menggunakan versi baru `\docat` (seperti ini `\docat{$90}`) maka *tampak* seolah-olah `$90` masih digunakan sebagai argumen untuk `\docat` makro. Namun, seperti dibahas di atas, ketika TeX mendeteksi `\docat` dalam input ia memeriksa apakah ia memiliki argumen: sekarang tidak, jadi TeX melanjutkan untuk mengeksekusinya (memperluasnya). Perluasan `\docat` adalah urutan token `**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**spasi**`, `**getarg**` dan ini terjadi *sebelum* TeX mulai membaca (menokenisasi) karakter berikutnya yang terdapat dalam berkas input—yaitu, kelompok `{$90}`. Ingat bahwa ketika TeX memperluas sebuah makro, ia mendapatkan input berikutnya dengan membaca token yang terdapat dalam daftar token definisi makro tersebut; yaitu, dari `<teks pengganti>` bagian yang tersimpan di memori.

TeX akan memproses, dan menjalankan, perluasan `\docat` dan mendeteksi *token* **`getarg`**, mengenalinya sebagai token yang mewakili perintah yang menerima parameter. Pada titik ini, TeX akan memindai berkas input untuk **`getarg`**&#x61;rgumen `{$90}`. Seperti biasa, ini ditokenisasi tetapi karena TeX telah membaca dan memproses perluasan `\docat`, karakter `$90` ditokenisasi ketika kode kategori `$` telah diubah menjadi 11. Definisi (`<teks pengganti>`) dari `\getarg` hanyalah `#1` yang berarti menata argumen yang diberikan, dan itulah yang terjadi, menghasilkan sebuah `$` dengan kode kategori 11 yang dihasilkan dan ditata dengan aman.

## Catatan penutup: kisah dalam node

Urutan peristiwa yang timbul dari menulis ulang `\docat` untuk menggunakan makro `\getarg` tercantum dalam diagram daftar node beranotasi berikut yang menunjukkan proses perluasan untuk makro `\docat`. Pembaca yang ingin mempelajari diagram ini dengan saksama dapat mengunduh grafiknya sebagai [PDF](https://assets.ctfassets.net/nrgyaltdicpt/7MOBdavza4WxAEQGISEEht/cabe5097d9063a6415bc553cd38237e6/newdocatexpansion.pdf) atau [SVG](https://images.ctfassets.net/nrgyaltdicpt/2FIqqVRXjakdAzTpZsV0m9/10ccc1353741d42d3df18f1692d8aa84/newdocatexpansion--plain.svg) file untuk penggunaan luring.

![Menunjukkan proses memperluas makro \docat yang dimodifikasi dan makro \getarg](/files/87eae504123df8b57058faa7f0329d4017146f8a)

[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/24-how-tex-macros-actually-work-part-6.md?ask=<question>&goal=<endgoal>
```

`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.