> 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/22-how-tex-macros-actually-work-part-4.md). # Bagaimana makro TeX sebenarnya bekerja: Bagian 4 [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 Dalam Bagian 1–3 kita mendalami beberapa detail latar belakang tingkat rendah sebagai persiapan untuk memahami cara kerja makro TeX. Dalam artikel ini kita akan “menghirup udara sejenak” untuk meninjau beberapa prinsip praktis dasar makro TeX sebagai bekal untuk pendalaman lain di Bagian 5 dan 6. Sepanjang artikel ini kita akan menunjukkan contoh makro yang didefinisikan menggunakan perintah primitif TeX `\def`: kita tidak akan menggunakan perintah LaTeX, yang mungkin lebih familiar, `\newcommand`. Ada alasan yang sangat baik untuk ini: tujuan kita adalah memahami prinsip-prinsip fundamental yang mendasari perilaku makro TeX, tetapi untuk itu kita perlu menggunakan perintah inti *yang dibangun ke dalam* perangkat lunak TeX. Perintah LaTeX, seperti `\newcommand`, pada dasarnya adalah makro: perintah dengan perilaku terprogram tertentu yang pada akhirnya dibangun dari lapisan-lapisan perintah primitif TeX tingkat lebih rendah. Untuk lebih memahami perilaku fundamental TeX kita harus menggunakan primitif TeX, bukan makro LaTeX. ### Ke mana arah pembahasan kita? Pada dasarnya, kita sedang menuju penjelasan tentang makro sebagai bentuk khusus dari daftar token: ketika Anda menginstruksikan TeX untuk mendefinisikan sebuah makro, TeX membuat rangkaian token (daftar token) dan menyimpannya dalam memorinya yang terkait dengan nama yang Anda tentukan. Di Bagian 5 dan 6 kita akan melihat daftar token makro secara lebih rinci, tetapi jika Anda lebih suka meninggalkan artikel ini untuk membaca informasi latar belakang, Anda dapat menemukannya di [Apa itu daftar token TeX?](/latex/id/artikel-mendalam/54-what-is-a-tex-token-list.md) Daftar token untuk makro, dan parameternya, mencakup beberapa seluk-beluk tambahan yang akan kita bahas secara rinci—dan menggunakan banyak contoh. Untuk lebih memahami perilaku pemrosesan makro TeX, sebenarnya ada satu faktor kunci yang perlu diingat: TeX hanya memikirkan karakter pada tahap paling awal pemrosesan masukan; setelah itu yang ada hanyalah token! Sepanjang ini, dan artikel-artikel berikutnya dalam seri ini, kita akan mengeksplorasi peran token dalam makro TeX. ## Empat bagian dari sebuah makro ### Pengingat: parameter makro dan argumen makro Sebelum kita mulai, ada baiknya kita mengingat kembali perbedaan antara *parameter* dan *argumen*sebuah makro, karena kita akan menggunakan kedua istilah ini sepanjang artikel ini. Misalkan Anda mendefinisikan makro \foo ``` \def\foo#1#2{This is #1, this is #2} ``` Konstruksi (token) `#1`, `#2` (hingga `#9`) disebut *parameter*: anggaplah mereka sebagai “penampung” untuk data aktual yang akan Anda gunakan saat memanggil makro: ``` \foo{alpha}{beta} ``` Di sini, `alpha` dan `beta` adalah *argumen* yang digunakan pada pemanggilan \foo ini: argumen makro adalah nilai aktual yang dimasukkan ke penampung parameter (`#1`, `#2`... `#9`) yang digunakan ketika Anda mendefinisikan makro. ### Definisi makro: memiliki 4 elemen Kita akan mulai dengan sesuatu yang mungkin tampak seperti definisi makro yang agak formal, tetapi ini memberikan kerangka kerja yang berguna untuk pembahasan selanjutnya. Setiap definisi makro terdiri dari 4 bagian: ``` {} ``` di mana: * ``: salah satu dari `\def`, `\edef`, `\gdef` atau `\xdef`; * ``: nama yang diberikan pada perintah makro Anda, seperti `\foo`; * ``: ini bisa tidak ada, tetapi jika ada, ini adalah rangkaian *token* yang muncul sebelum `` dari makro. Teks pengganti `` dapat berisi parameter makro (`#1`, `#2`... `#9`) dan jenis token lainnya. Pada dasarnya, dan seperti akan kita lihat secara rinci, `` memberikan semacam *templat token* yang digunakan TeX untuk menentukan token mana yang ingin dipakai pengguna sebagai argumen makro: ketika Anda memanggil makro, TeX memasukkan *argumen* token ke dalam `` (yang juga merupakan daftar token); * `{}`: ini adalah isi sebenarnya dari makro Anda: ini adalah serangkaian token tempat *argumen* disisipkan saat makro diproses (diekspansi). Argumen dimasukkan ke posisi yang ditunjukkan oleh parameter makro yang digunakan dalam definisi asli. **CATATAN**: Sepanjang pembahasan ini kita mengasumsikan bahwa `` akan diikuti oleh karakter spasi dengan kode kategori 10 untuk berfungsi sebagai pemisah yang mengakhiri ``. Kita *tidak* secara eksplisit menampilkan karakter spasi itu dalam teks/pembahasan kita, tetapi kita mengasumsikannya ada. Secara teknis, kita seharusnya merepresentasikannya seperti ini: ``` {} ``` Namun, kita akan menghilangkan penyertaan eksplisit dari sebuah `` karakter dan secara implisit menganggap keberadaannya. #### Catatan tentang {} Kita telah menunjukkan penggunaan dua kurung kurawal: `{` dan `}` yang mengapit (membatasi) isi sebenarnya dari ``. Namun, penggunaan `{` dan `}` hanyalah konvensi yang diadopsi karena yang sebenarnya diharapkan TeX adalah teks makro Anda `` untuk dimulai dengan karakter berkode kategori 1 (“Mulai sebuah grup”) dan ditutup dengan karakter berkode kategori 2 (“Akhiri sebuah grup”). Secara konvensi, ini adalah `{` dan `}` karakter tersebut secara berurutan. Namun, jika Anda mau, Anda dapat menetapkan pasangan karakter apa pun untuk melakukannya. Misalnya ``` \catcode`\(=1 \catcode`\)=2 ``` Sekarang, Anda dapat mendefinisikan dan menggunakan makro seperti ini: ``` \def\foo #1(Hello, #1) \foo(World!) ``` Dan Anda masih dapat menggunakan `{` dan `}` karena kita belum mengubah kode kategori mereka—banyak karakter dapat, dan memang memiliki, kode kategori yang sama, jadi Anda tetap dapat mendefinisikan makro dengan cara biasa: ``` \def\foo #1{Hello, #1} \foo{World!} ``` ### dan {} Komponen definisi makro yang paling relevan dengan pembahasan kita adalah `` dan `{}`. Ketika Anda mendefinisikan makro, `` pada dasarnya adalah templat token yang ketat yang menentukan bagaimana makro harus digunakan. Seperti telah dicatat, `` dapat kosong, mis., `\def\foo{Some text}` di mana tidak ada apa pun yang muncul di antara nama perintah kita (`\foo`) dan kurung kurawal pembuka `{` yang, di sini, menandai awal dari ``. **Catatan**: Beberapa pembaca mungkin mengetahui mekanisme “hashquote” TeX (`#{`) tetapi kita tidak akan membahasnya di sini. ### dan pemisah makro Artikel ini tidak dirancang sebagai ulasan yang benar-benar menyeluruh tentang penulisan makro, tetapi ada baiknya kita meninjau ulang secara singkat, dengan beberapa contoh, yang menunjukkan bahwa `` bisa menjadi rumit karena TeX memungkinkan `` untuk berisi: * **parameter makro**: (`#1`, `#2`,... `#9`) yang bertindak sebagai “penampung” untuk nilai yang akan diberikan pengguna saat mereka menjalankan makro—yaitu *argumen*; * **token pemisah**: token sembarang, disisipkan di antara/sekeliling token parameter, dan digunakan untuk menentukan batas di antara parameter makro. Anda dapat menganggap pemisah itu sebagai membentuk jenis “tanda baca” yang membuat `` sebuah “templat token” yang perlu Anda ikuti saat menggunakan makro. Token pemisah tidak dicetak. Jadi apa artinya ini sebenarnya—marilah kita lihat beberapa contoh. `` berada di antara nama makro dan kurung kurawal kiri `{` dari definisi makro. #### Pemisah: Contoh 1 Misalkan kita mendefinisikan makro dasar `\foo` sebagai berikut: ``` \def\foo ABC{hello, there} ``` * `` = `ABC` * Tidak ada token parameter (`#1`, `#2`,... `#9`) * Pemisahnya adalah *tiga token karakter* `ABC` tetapi, dalam contoh ini, mereka agak berlebihan dan hanya digunakan sebagai contoh. Tiga token karakter `ABC` diperlakukan sebagai pemisah: bukan sesuatu yang dicetak melainkan “tanda baca” yang diharapkan ada saat makro dipanggil—ketika Anda menggunakan makro `\foo` Anda harus menyediakan pemisah yang sama seperti yang ada saat makro itu didefinisikan. Jika Anda mengetik `\foo ABC` di dalam teks Anda ini akan mencetak `hello, there`—token karakter `ABC` tidak dicetak tetapi TeX, dengan sangat hati-hati, memeriksa untuk memastikan bahwa token-token itu ada dalam pemanggilan (call) Anda atas `\foo`. TeX mencari pemisah tersebut (“tanda baca”) dan menghapusnya (menyerapnya) seperti yang dapat Anda lihat pada gambar layar Overleaf berikut: `ABC` tidak dicetak: ![Overleaf menjalankan makro TeX](/files/c6127371fb1c3202468b6a94d8ba4d7aef32151e) Jika Anda mencoba menggunakan `\foo` tanpa `ABC` pemisah, TeX akan mengeluh `Penggunaan \foo tidak cocok dengan definisinya.`: ![Menampilkan kesalahan TeX di Overleaf](/files/8c5a30c8c36bd8aa534de39b345246c6d9cf55c5) Pada contoh di atas, setelah mendeteksi `\foo` TeX mengharapkan melihat tiga token karakter `ABC` tetapi tidak: TeX melihat token karakter untuk `w` dan segera mendeteksi ada sesuatu yang salah. #### Pemisah: Contoh 2 Fakta yang menarik, dan mungkin mengejutkan, adalah bahwa pemisah dapat berupa token perintah apa pun—termasuk perintah yang bahkan belum *didefinisikan*. Misalnya, kita dapat mendefinisikan `\foo` sebagai berikut: ``` \def\foo A\bob B\anne{Hello \TeX{}} ``` * `` = `A\bob B\anne` * Tidak ada token parameter (`#1`, `#2`,... `#9`) * Pemisahnya adalah token-token `A\bob B\anne` tetapi lagi-lagi, dalam contoh ini, mereka berlebihan dan hanya untuk tujuan pembahasan. Perhatikan bahwa `\bob` dan `\anne` adalah perintah fiktif yang *tidak didefinisikan*—dan tidak perlu didefinisikan. Saat Anda memanggil makro, TeX memeriksa (memindai) `` yang ada *dalam pemanggilan makro Anda* dan membandingkannya, token demi token, dengan versi “templat token” *yang disimpan dalam memori*—yang dibuat pada saat makro didefinisikan. TeX memindai *yang digunakan dalam pemanggilan makro Anda* dan cukup mengonversi perintah apa pun yang ditemukannya di sana ke nilai token numeriknya: ia tidak berusaha mengeksekusi perintah-perintah itu, sehingga tidak masalah bahwa `\bob` dan `\anne` tidak pernah didefinisikan. TeX hanya menggunakan templat token yang disimpan dalam memori sebagai panduan yang memungkinkannya menentukan token mana dalam `` dari pemanggilan makro Anda yang merupakan argumen aktual untuk dimasukkan ke dalam ``. Seperti yang dapat Anda lihat dari cuplikan layar Overleaf berikut, tidak satu pun dari token karakter (`Sebuah` dan `B`) di dalam `A\bob B\anne` dicetak dan perintah yang tidak didefinisikan `\bob` dan `\anne` tidak menimbulkan masalah apa pun. Semua token ini *diserap* oleh TeX saat ia mencocokkan penggunaan Anda atas `\foo` dengan definisi (templat token) dari `\foo` (sebuah daftar token) yang disimpan dalam memori. ![Overleaf menjalankan makro TeX](/files/7233efce9c2de9aa9ab7c34e7d395138eb14de1d) #### Pemisah: Contoh 3 Anda dapat menyisipkan berbagai pemisah (token karakter, token perintah) di antara parameter makro, seperti pada contoh ini: ``` \def\foo A\bob#1B\anne#2\jane#3bye!{Hello from \TeX{} to \#1=#1, \#2=#2 and \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3bye!` * Ada 3 token parameter makro: `#1`, `#2`, `#3` * Kali ini, parameter (`#1`, `#2`, `#3`) dibatasi oleh kombinasi token: `A\bob#1B\anne#2\jane#3bye!` Di sini, pada dasarnya, Anda telah memberikan TeX sebuah templat yang akan ia coba, dengan sangat hati-hati, dan ia harapkan untuk dicocokkan saat Anda memanggil `\foo`: ia akan menelusuri pemanggilan makro Anda, *token demi token*, dan mengharapkan untuk mencocokkan (menemukan): * dua token `Sebuah` dan `\bob` sebelum `#1` * dua token `B` dan `\anne` sebelum `#2` * token `\jane` sebelum parameter `#3` dan *empat token karakter* `b`, `y`,`e` dan `!` setelah `#3`. **Ingat**: TeX berpikir dalam token jadi `bye!` adalah *empat token karakter*. Ada dua cara kita dapat menggunakan makro ini—kita bisa menaruh argumen multi-token apa pun di dalam kurung kurawal untuk menyediakan satu grup: ``` \foo A\bob{This}B\anne{That}\jane{Other}bye! ``` Namun, itu *tidak diperlukan* karena definisi makro kita memiliki pemisah yang menyediakan templat token. TeX dapat menggunakan templat itu untuk memilih token bagi setiap argumen dari antara token yang murni merupakan pemisah. Kita dapat menggunakan makro kita seperti ini: ``` \foo A\bob ThisB\anne That\jane Otherbye! ``` dan TeX dapat memilih argumen untuk menghasilkan hasil yang sama seperti saat menggunakan grup `{...}`: ![Overleaf menjalankan makro TeX menggunakan pemisah](/files/a94f2d5976bff41dcaa59a2a2a9606b5a818bedc) Perhatikan bagaimana TeX mampu mendeteksi, dengan tepat, token mana yang cocok dengan parameter `#1` dan `#3`: ![Overleaf menjalankan makro TeX menggunakan pemisah](/files/90e0195b12f26938ce4cf13497b1cc6e9c5f882f) #### Pemisah: Contoh 4 (ini semua tentang token, bukan karakter!) Berikut adalah contoh singkat untuk menunjukkan bahwa, saat bekerja dengan makro, penting untuk mengingat bahwa kita benar-benar berada di dunia *token* dan **berisi nilai data aktual yang disimpan dalam** *karakter*… Kita akan mendefinisikan makro singkat berikut di mana A dan B adalah karakter yang bertindak sebagai pemisah dan keduanya memiliki kode kategori 11. Ini berjalan tanpa masalah: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hello, #1} \foo AGrahamB \end{document} ``` dan mencetak `Hello, Graham`. Namun, jika Anda mengubah kode kategori A atau B menjadi selain 11, pemanggilan makro akan gagal. Misalkan kita mengubah kode kategori B menjadi 12, menggunakan ``\catcode`B=12`` dan mencoba memanggil makro itu lagi, seperti sebelumnya: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hello, #1} \foo AGrahamB % This works \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Ia gagal dengan kesalahan yang agak membingungkan: ``` Argumen melarikan diri? GrahamB \end {document} ! Berkas berakhir saat memindai penggunaan \foo. \par <*> main.tex Saya menduga Anda lupa sebuah `}', menyebabkan saya membaca melewati tempat yang Anda inginkan agar saya berhenti. Saya akan mencoba memulihkan; tetapi jika kesalahannya serius, sebaiknya Anda ketik `E' atau `X' sekarang dan perbaiki berkas Anda. ! Hentian darurat. <*> main.tex *** (pekerjaan dibatalkan, tidak ditemukan \end yang sah) ``` ![Overleaf menampilkan kesalahan makro TeX](/files/27ac4b7b7a37e0905b1943e6751b90844edd1c52) Sayangnya, saran bawaan TeX berupa ``Saya menduga Anda lupa sebuah `}'`` adalah **tidak tepat**, itu tidak disebabkan oleh kurung kurawal yang hilang (`}`). #### Apa yang telah terjadi? TeX mencoba mencocokkan `\foo` makro *pemanggilan* dengan `\foo` makro *definisi* yang disimpannya dalam memori. Saat Anda memanggil makro yang memerlukan satu atau lebih argumen, TeX harus memeriksa (memindai) penggunaan makro Anda untuk menentukan *argumen* yang Anda berikan ke makro tersebut. Di sini, TeX mengharapkan argumen berada di antara A (kode kategori 11) dan B (kode kategori 11). Ingat: TeX berpikir dalam *token*, **berisi nilai data aktual yang disimpan dalam** *karakter*. Nilai token untuk A dan B, $$\mathrm{T\_A}$$ dan $$\mathrm{T\_B}$$ masing-masing, adalah: $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Namun, saat TeX melanjutkan pencariannya, ia melihat B *tetapi* sekarang B memiliki kode kategori 12 dan itu menghasilkan nilai token yang berbeda: $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ Pada `\foo` dalam definisi makro, nilai token untuk B (yang digunakan sebagai pemisah) adalah 2882 tetapi TeX sekarang melihat nilai token 3138: ia mengira ini hanyalah token lain yang akan digunakan dalam *argumen* yang diberikan kepada `\foo`. Bagi TeX, token terakhir dari argumen belum ditemukan jadi ia mengambil token lain dalam pencariannya untuk B dengan kode kategori 11. Itulah saat, dan alasan, makro gagal: dalam usahanya menemukan argumen, TeX “melampaui batas” dan mulai membaca token yang tidak Anda maksudkan untuk menjadi bagian dari argumen bagi `\foo` pemanggilan makro. Apa yang terjadi selanjutnya bergantung pada token-token yang ditemukan TeX setelah B—token-token itu akan memicu berbagai `Argumen melarikan diri?` kesalahan. Dalam contoh kita, TeX melampaui batas dan mengonsumsi aliran token `\end {document}` dan dengan cepat mencapai akhir berkas, sehingga pesan kesalahannya: ``` ! Berkas berakhir saat memindai penggunaan \foo ``` ## Bagian 5 Seperti yang kita lihat di atas, `` bagian dari definisi makro kita dapat berkisar dari yang sangat sederhana hingga campuran kompleks parameter makro yang diselingi token karakter dan token perintah yang bertindak sebagai pemisah. TeX mampu memproses berbagai kombinasi token yang terdapat dalam `` untuk mengekstrak argumen yang diberikan kepada sebuah makro—dan mendeteksi ketika kita mencoba menggunakan makro secara tidak benar. Bagaimana caranya itulah yang menjadi topik artikel berikutnya dalam seri ini. [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/22-how-tex-macros-actually-work-part-4.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.