> 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/18-how-overleaf-created-the-tex-primitive-reference-data.md).

# Bagaimana Overleaf membuat data referensi primitif TeX

Artikel ini menjelaskan metode dan teknik yang digunakan untuk menghasilkan dua tabel silang-referensi perintah primitif TeX:

* [Primitif TeX yang dicantumkan berdasarkan mesin TeX](/latex/id/topik-lainnya/46-tex-primitives-listed-by-tex-engine.md) dan;
* [Primitif TeX yang dicantumkan berdasarkan mesin CJK TeX](/latex/id/topik-lainnya/45-tex-primitives-listed-by-cjk-tex-engine.md).

Informasi ini disediakan bagi pembaca yang tertarik pada rincian yang lebih halus, tetapi bukan merupakan prasyarat untuk menggunakan tabel silang-referensi itu sendiri. Untuk memenuhi kebutuhan pembaca yang berbeda, kami menyediakan versi ringkasan yang sangat singkat beserta penjelasan yang lebih panjang bagi mereka yang ingin menelaah isu-isu tersebut lebih mendalam.

## Versi ringkasan/gambaran umum singkat

Untuk membangun tabel silang-referensi, Overleaf memproses kode sumber dari 9 mesin TeX untuk mengekstrak daftar primitif yang didukung oleh masing-masing: proses itu menghasilkan 9 berkas teks (1 berkas per mesin TeX). Kesembilan set primitif tersebut digabungkan untuk membuat “daftar induk” yang, pada dasarnya, merupakan gabungan dari set primitif individual: menghasilkan total sekitar 1000 primitif unik yang tersebar di berbagai mesin. Untuk setiap mesin, daftar primitifnya sendiri disilang-referensikan dengan berkas induk (set semua perintah) untuk menentukan mana dari \~1000 perintah itu yang didukungnya: perbandingan tersebut ditabulasi dalam dua tabel berikut:

* [Data silang-referensi primitif TeX](/latex/id/topik-lainnya/46-tex-primitives-listed-by-tex-engine.md)
* [Data silang-referensi primitif TeX (untuk mesin CJK)](/latex/id/topik-lainnya/45-tex-primitives-listed-by-cjk-tex-engine.md)

## “Membangun perangkat lunak” 101: Apa artinya itu?

Sepanjang sisa artikel ini kami merujuk pada gagasan “membangun mesin TeX”, yang mungkin merupakan konsep yang asing jika Anda bukan seorang programmer, atau tidak memprogram dalam bahasa terkompilasi seperti C atau C++. Untuk tujuan kita, membangun perangkat lunak—yaitu mesin TeX—adalah proses membuat program TeX yang dapat dieksekusi dari bagian-bagian penyusunnya—berkas-berkas kode sumber yang ditulis dalam bahasa pemrograman yang digunakan untuk mengembangkan program tersebut.

## Versi lengkap: Ingin detailnya? Baca terus...

Setiap mesin penataan huruf berbasis TeX mendukung “dialek” bahasa TeX: seperangkat perintah primitif tertentu yang mengendalikan fitur penataan huruf dari tiap mesin dan menyediakan blok bangunan untuk membuat/menentukan makro: urutan perintah yang didefinisikan pengguna. Setiap makro, apakah ditulis untuk LaTeX, plain TeX, atau paket makro lainnya, pada akhirnya dibangun dari perintah primitif—meskipun Anda mungkin perlu menelusuri cukup jauh, melalui lapisan-lapisan makro tambahan, sebelum mencapai “lapisan dasar” primitif TeX. Set perangkat 9 mesin TeX yang dianalisis untuk menghasilkan data referensi perintah primitif tentu memiliki banyak perintah yang sama, tetapi setiap mesin TeX juga memiliki perintah primitifnya sendiri, yang ditambahkan oleh pengembangnya, untuk mendukung fitur-fitur khusus pada “versi” TeX tersebut.

Perintah primitif sebuah mesin TeX dibangun ke dalam perangkat lunak TeX yang dapat dieksekusi: primitif bukanlah makro yang dibangun oleh pengguna, melainkan instruksi fundamental, tak terpisahkan/atomik, yang digunakan untuk mengendalikan perilaku penataan huruf dari tiap mesin. Karena itu, cara paling andal untuk membuat daftar definitif perintah primitif yang didukung oleh mesin TeX mana pun adalah dengan memeriksa kode sumber aktual dari mana program TeX yang dapat dieksekusi itu dibangun (dikompilasi) dan mengekstrak daftar primitif yang didefinisikan dalam kode sumber tersebut. Kedengarannya seharusnya mudah, bukan? Namun, karena sejarah pengembangan TeX selama 40 tahun, menelusuri/memeriksa berkas-berkas kode sumber mesin TeX (kecuali LuaTeX) tidaklah sangat langsung. Penyebab kerumitan itu terletak pada alat, bahasa pemrograman (Pascal), dan metodologi (pemrograman literat) yang digunakan Knuth untuk menulis kode sumber TeX asli—dari mana semua mesin lain, pada akhirnya, berasal.

Kami mencatat pengecualian untuk LuaTeX karena kode mesin intinya ditulis ulang dalam C untuk menghapus penggunaan Pascal dan kompleksitas warisan lain yang dirinci di bawah ini (Web2C); akibatnya, walaupun kode sumber LuaTeX cukup besar, cara “pengemasan” dan pendistribusiannya jauh lebih mudah dipahami dibandingkan mesin TeX lainnya. Karena itu, dan berdasarkan alur kerja/proses yang digunakan untuk membangunnya dari kode sumber, mudah untuk mengelompokkan mesin TeX ke dalam dua kategori:

1. LuaTeX: proses pembangunan kustom (lebih modern)
2. Semua mesin lain: proses pembangunan warisan (Web2C)

## Konteks kode warisan: Mengapa membangun (sebagian besar) mesin TeX itu rumit

Seperti yang akan kita bahas di bawah, Knuth merilis kode sumber TeX aslinya sebagai satu berkas monolitik yang disebut `tex.web` yang, setiap 7 tahun, terus diperbarui Knuth untuk memperbaiki bug yang tersisa—tidak pernah ada fitur baru yang ditambahkan, ini murni latihan perbaikan bug.

Ekstensi berkas dari kode sumber TeX (`.web`) kemungkinan tidak familiar dan Anda mungkin bertanya bahasa apa yang dipakai Knuth untuk menulis TeX? Jawabannya adalah Pascal tetapi `.web` ekstensinya perlu sedikit penjelasan lagi. Knuth mengembangkan metodologi pemrograman yang ia sebut [pemrograman literat](https://en.wikipedia.org/wiki/Literate_programming) di mana kode sumber dan dokumentasi sebuah program digabungkan dan dirilis sebagai satu berkas komposit (kode plus dokumentasi) dengan ekstensi `.web`: jenis berkas itu disebut berkas WEB. Kami menjelaskan berkas WEB sedikit lebih rinci di bawah ini.

### Membuat mesin TeX baru: ketentuan Knuth

Walaupun Knuth sejak lama telah membuat kode sumber TeX-nya (`tex.web`) tersedia bebas bagi semua orang, ia memang, sebagaimana hak mutlaknya, menetapkan syarat penting bahwa kode sumber (`tex.web`)-nya tidak boleh diedit/dimodifikasi secara langsung dan didistribusikan ulang dengan nama program “TeX”. Dalam kode sumber ia menulis:

```
% Program ini memiliki hak cipta (C) 1982 oleh D. E. Knuth; semua hak dilindungi.
% Penyalinan berkas ini diizinkan hanya jika (1) Anda adalah D. E. Knuth, atau jika
% (2) Anda sama sekali tidak membuat perubahan apa pun pada salinan Anda. (Sistem WEB menyediakan
% untuk perubahan melalui berkas tambahan; berkas induk harus tetap utuh.)
```

dan juga:

```
Jika program ini diubah, sistem yang dihasilkan tidak boleh disebut
`\TeX'; nama resmi `\TeX' itu sendiri dicadangkan
untuk sistem perangkat lunak yang sepenuhnya kompatibel satu sama lain.
Sebuah rangkaian uji khusus yang disebut ``\.{TRIP} test'' tersedia untuk
membantu menentukan apakah suatu implementasi layak disebut
dikenal sebagai `\TeX' [bdk.~laporan Ilmu Komputer Stanford CS1027,
November 1984].
```

Intinya: jangan membuat perubahan dengan menyunting dan mendistribusikan versi yang dimodifikasi dari kode sumber induk TeX dan terus menyebutnya `tex.web`. Jika Anda memang ingin membuat perubahan, misalnya menambah primitif baru, dll., maka Anda harus menerapkan perubahan tersebut dengan membuat “perubahan melalui berkas tambahan” dan memberi program “turunan dari TeX” Anda nama yang membedakannya dari “TeX”, yang, dalam bentuk teretakkan ($$\mathrm\TeX$$), adalah merek dagang dari American Mathematical Society.

### Warisan dari yang lama

Meskipun telah ada upaya untuk menulis ulang TeX sepenuhnya menggunakan bahasa dan metodologi pemrograman modern—seperti dua inisiatif berbasis Java [Sistem Penataan Huruf Baru](https://en.wikipedia.org/wiki/New_Typesetting_System) dan [εχTEX](http://www.extex.org/) dan lainnya seperti [yang berbasis Clojure](https://www.infoq.com/news/2015/01/implementing-tex-in-clojure), tidak ada yang berhasil sepenuhnya. Sejarah proyek dan inisiatif yang dirancang untuk mengembangkan TeX lebih lanjut adalah topik yang menarik dan pembaca mungkin ingin [mengunjungi UK TeX FAQ](https://texfaq.org/FAQ-enginedev) untuk informasi lebih lanjut.

Inisiatif non-LuaTeX yang juga berhasil, seperti e-TeX, pdfTeX, XeTeX, dan mesin lainnya, telah membangun *langsung di atas* kode asli Knuth: mengambil kode sumbernya dan “menerapkan perubahan” untuk menurunkan mesin baru dengan kemampuan tambahan—seperti menambahkan primitif baru, menghasilkan keluaran PDF, mendukung input teks UTF-8, dan sebagainya. Walaupun jalur itu telah menghasilkan keberhasilan yang nyata, itu juga berarti bahwa mesin turunan tersebut mewarisi kode warisan dan teknik pengembangan yang diciptakan Knuth 40 tahun lalu.

Inti yang perlu diambil di sini adalah bahwa, selain LuaTeX, sebagian besar mesin TeX yang diturunkan dari kode sumber asli Knuth dibuat dengan mengambil satu berkas monolitik (biasanya `tex.web`) dan menerapkan perubahan yang menghasilkan satu berkas monolitik lain yang berisi kode sumber inti mesin baru tersebut. Pembaca tingkat lanjut mungkin ingin melompat ke [catatan yang menjelaskan pdfTeX dan XeTeX](#aside-xetex-and-pdftex).

### Sedikit sejarah/latar belakang tambahan TeX

Momen genesis TeX adalah [dicatat dalam buku harian Knuth sebagai 30 Maret 1977](/latex/id/artikel-mendalam/55-what-s-in-a-name-a-guide-to-the-many-flavours-of-tex.md#the-genesis-of-tex-a-brief-history), kini lebih dari 40 tahun yang lalu. Secara internal, TeX adalah program yang luar biasa kompleks, yang kode sumbernya ditulis Knuth dengan sangat teliti untuk [didokumentasikan dengan rincian yang luar biasa](https://www.amazon.co.uk/Computers-Typesetting-TeX-Program-TEX/dp/0201134373). Untuk melakukan itu Knuth mengembangkan gaya pemrograman yang ia sebut [pemrograman literat](https://en.wikipedia.org/wiki/Literate_programming) di mana kode sumber dan dokumentasi sebuah program digabungkan bersama dan dirilis sebagai berkas komposit dengan ekstensi `.web` (disebut sebagai berkas WEB). Knuth memilih Pascal sebagai bahasa pemrograman untuk menulis perangkat lunak TeX-nya dan, tidak mengherankan, menggunakan bahasa penataan huruf TeX untuk menulis dokumentasi akhirnya. Karena itu, kode sumber induk TeX milik Knuth diterbitkan sebagai satu berkas monolitik yang disebut `tex.web`: campuran kode sumber Pascal dan kode penataan huruf TeX untuk dokumentasinya.

Jika sebuah program ditulis menggunakan gaya/metodologi pemrograman literat ala Knuth (seperti TeX, MetaFont, BibTeX, dan lainnya), Anda perlu melakukan pra-pemrosesan pada berkas WEB untuk mengekstrak dokumentasi atau kode sumbernya. Untuk mengakses dokumentasi program Anda memproses berkas WEB (misalnya, `tex.web`) dengan utilitas yang disebut [WEAVE](http://tug.org/texinfohtml/web2c.html#weave-invocation) yang menghasilkan dokumentasi sebagai `.tex` berkas yang dapat Anda tata hurufkan. Untuk mengekstrak kode sumber dalam Pascal Anda menggunakan utilitas lain yang disebut [TANGLE](http://tug.org/texinfohtml/web2c.html#tangle-invocation) yang mengeluarkan berkas dengan ekstensi `.p` yang berisi kode sumber Pascal.

Pada saat penulisan ini (awal 2019) versi terbaru TeX karya Knuth adalah 3.14159265, bertanggal Januari 2014. Sekali lagi, perhatikan bahwa kode sumber TeX karya Knuth hanya berada dalam satu berkas yang berisi sekitar 25.000 baris kode TeX/Pascal!

### Dari Pascal ke C

Selama lebih dari 40 tahun yang telah berlalu sejak lahirnya TeX, Pascal kehilangan popularitas dan kini hanya sedikit, jika ada?, orang yang mempertimbangkan untuk membangun TeX dari kode sumber Pascal aslinya. Untuk menghindari penggunaan Pascal oleh Knuth, dirancanglah alur kerja yang disebut [Web2C](http://tug.org/texinfohtml/web2c.html) yang, pada sekitar 1987, mengonversi kode sumber Pascal TeX secara mekanis (yaitu melalui perangkat lunak) ke padanannya dalam kode C, yang kemudian digunakan untuk mengompilasi TeX dan membangun program yang dapat dieksekusi. Ini bekerja dengan baik tetapi satu-satunya kelemahannya adalah bahwa kode sumber C yang dihasilkan secara mekanis tidak dimaksudkan untuk pemeriksaan manusia secara santai: kode itu *sangat* bertele-tele dan hampir tak tembus, karena ditujukan untuk kompiler, bukan manusia—berikut ini adalah tangkapan layar yang menunjukkan fragmen kecil kode C yang dihasilkan dari kode sumber Pascal TeX:

![](/files/585f5434ecfde9c1a4a7dd059c7835cacf6229f6)

### Knuth-isme lainnya: berkas perubahan WEB

Seperti dicatat di atas, untuk membangun di atas kode sumber asli Knuth Anda “menerapkan perubahan” atau, dalam kata-kata Knuth, membuat “perubahan melalui berkas tambahan”: tetapi apa sebenarnya artinya ini? Masuklah mekanisme *berkas perubahan*.

### Berkas perubahan: mekanisme untuk membuat mesin TeX baru

Pengembang yang ingin memperluas TeX Knuth dengan cara tertentu, yaitu membangun di atas karya asli Knuth, biasanya ingin membuat “versi” TeX yang sepenuhnya baru atau menyediakan sebuah *ekstensi* yang dapat ditambahkan ke mesin TeX mana pun. Contoh ekstensi mencakup [SyncTeX](https://github.com/jlaurens/synctex) dan [EncTeX](https://ctan.org/pkg/enctex?lang=en)—SyncTeX, misalnya, adalah ekstensi yang sangat berguna yang kini disertakan di semua mesin TeX. Kebutuhan akan EncTeX sebagian besar telah digantikan oleh evolusi mesin TeX yang sadar-Unicode—tetapi perhatikan bahwa EncTeX dibangun ke dalam pdfTeX.

Apakah tujuannya untuk menghasilkan “versi” baru TeX (yaitu turunan dari TeX asli Knuth), atau untuk membuat ekstensi, para pengembangnya memulai dengan kode sumber asli Knuth dan menerapkan modifikasi yang diperlukan untuk membuat mesin TeX baru (atau ekstensi tambahan). Namun, seperti dicatat di atas, siapa pun yang ingin mengubah perilaku TeX perlu melakukannya dengan menggunakan “perubahan melalui berkas tambahan” karena perubahan/modifikasi tersebut tidak boleh diterapkan dengan *langsung* menyunting kode sumber asli Knuth: pengembang diwajibkan menggunakan yang disebut WEB *berkas perubahan*. Kode untuk memodifikasi TeX Knuth ditulis dalam “bahasa” WEB dan disimpan ke satu atau lebih berkas kode (disebut *berkas perubahan*) yang kemudian *digabungkan* dengan kode sumber induk asli Knuth yang tidak diubah. Proses penggabungan itu membuat berkas WEB komposit baru yang kini berisi *inti* kode sumber perangkat lunak berbasis TeX yang baru/diubah. *Berkas perubahan* sering memiliki ekstensi `.ch` tetapi dalam praktiknya, mereka dapat memiliki ekstensi apa pun yang diinginkan pengembang.

#### Bagaimana Anda menggunakan/menerapkan berkas perubahan?

Saat ini, cara termudah untuk menerapkan berkas perubahan dan memodifikasi berkas WEB “induk” adalah dengan program utilitas yang disebut [TIE](https://ctan.org/pkg/tie). Misalnya, Anda ingin memodifikasi TeX Knuth dengan menambahkan, katakanlah, beberapa primitif baru atau Anda ingin mengubah perilaku sebuah primitif TeX (standar) yang sudah ada. Anda akan menulis kode Anda (dalam Pascal!) menggunakan sistem pemrograman literat WEB dan menyimpannya ke berkas bernama, misalnya, `myprim.ch`. Langkah berikutnya adalah menggabungkan kode Anda (dalam `myprim.ch`) dengan berkas sumber induk Knuth `tex.web` dan menghasilkan berkas WEB komposit baru yang akan kita sebut `mytex.web`. Untuk melakukannya Anda cukup menjalankan program TIE seperti ini:

```
tie -m mytex.web tex.web myprim.ch
```

Dengan asumsi penggabungan berhasil, ini akan menghasilkan berkas WEB baru, `mytex.web`, sambil membiarkan berkas sumber induk Knuth `tex.web` tetap sama sekali tidak berubah, sebagaimana disyaratkan.

Sekarang mari kita asumsikan bahwa orang lain menyukai perubahan yang Anda buat dan ingin memodifikasi pekerjaan Anda untuk menambahkan perubahan mereka di atas, atau sebagai tambahan dari, apa yang telah Anda lakukan. Alih-alih mendistribusikan versi TeX Anda yang telah dimodifikasi (`mytex.web`) Anda memutuskan untuk memublikasikan/membagikan hanya berkas perubahannya, `myprim.ch`. Siapa pun yang ingin membangun di atas pekerjaan Anda kini dapat membuat dan membagikan berkas perubahan mereka sendiri yang disebut, misalnya, `moreprim.ch` yang memperluas kode Anda dengan cara tertentu. Orang lain yang ingin memanfaatkan kedua berkas perubahan itu kini dapat menghasilkan berkas WEB komposit baru dengan menggabungkan *keduanya* berkas perubahan ke dalam asli Knuth untuk menghasilkan program TeX lain yang, katakanlah, disebut `newmytex.web`:

```
tie -m newmytex.web tex.web myprim.ch moreprim.ch
```

### Sistem TeX nyata: banyak berkas perubahan

Deskripsi TIE di atas sebenarnya sangat dekat dengan cara banyak mesin TeX dibangun dalam praktiknya: mereka dimulai dengan `tex.web` Knuth dan menambahkan serangkaian berkas perubahan untuk menghasilkan berkas sumber WEB bagi mesin tersebut. Setiap mesin TeX memerlukan set berkas perubahan yang spesifik, yang harus diterapkan/diproses (digabungkan) dalam urutan yang ketat: jika urutannya salah, proses penggabungan akan gagal karena setiap berkas perubahan dalam suatu rangkaian bergantung pada perubahan yang diperkenalkan oleh berkas perubahan yang muncul lebih awal dalam rantai.

Berikut ini contoh eksekusi TIE yang menerapkan beberapa berkas perubahan ke `tex.web` Knuth untuk menghasilkan `ktex.web`—berkas WEB komposit dengan modifikasi pada TeX Knuth yang membuatnya siap (sesuai) untuk dikonversi ke C melalui proses Web2C. Perhatikan juga hal berikut:

* `tex.ch` adalah berkas perubahan yang sangat besar yang, di antara banyak hal lain, memodifikasi TeX untuk menggunakan Kpathsea;
* ekstensi SyncTeX ditambahkan melalui beberapa berkas perubahan.

```
tie -m ktex.web tex.web tex.ch enctex.ch synctex-def.ch0 synctex-mem.ch0 synctex-mem.ch2 synctex-rec.ch0 synctex-rec.ch1 synctex-rec.ch2 tex-binpool.ch
Ini adalah TIE, Versi CWEB 2.4.
Hak cipta (c) 1989,1992 oleh THD/ITI. Semua hak dilindungi.
(tex.web)
(tex.ch)
(enctex.ch)
(synctex-def.ch0)
(synctex-mem.ch0)
(synctex-mem.ch2)
(synctex-rec.ch0)
(synctex-rec.ch1)
(synctex-rec.ch2)
(tex-binpool.ch)
....500....1000....1500....2000....2500....3000....3500....4000....4500
....5000....5500....6000....6500....7000....7500....8000....8500....9000
....9500....10000....10500....11000....11500....12000....12500....13000
....13500....14000....14500....15000....15500....16000....16500....17000
....17500....18000....18500....19000....19500....20000....20500....21000
....21500....22000....22500....23000....23500....24000....24500....
(Tidak ditemukan kesalahan.)
```

#### Catatan tambahan: XeTeX dan pdfTeX

Untuk melengkapi pembahasan, kami perlu mencatat bahwa proses pembangunan untuk pdfTeX dan XeTeX sebenarnya tidak dimulai dengan `tex.web`Knuth; sebaliknya mereka dimulai dengan berkas yang disebut `pdftex.web` dan `xetex.web` masing-masing: mungkin karena perubahannya sangat luas sehingga lebih masuk akal untuk membagikan/menerbitkan berkas WEB yang sudah berisi modifikasi yang sangat signifikan pada kode asli Knuth.

### Sebuah contoh: e-upTeX

Komunitas TeX Jepang telah mengembangkan sejumlah mesin TeX yang dirancang untuk mengakomodasi kerumitan penataan huruf teks Jepang:

* **pTeX**: mesin TeX Knuth yang diperluas untuk mendukung penataan huruf Jepang;
* **e-pTeX**: Kombinasi e-TeX dan pTeX (ditambah beberapa primitif yang diperkenalkan oleh pdfTeX);
* **upTeX**: Versi pTeX yang sadar-Unicode plus ekstensi untuk penanganan CJK (Tionghoa, Jepang, dan Korea) yang lebih baik;
* **e-upTeX**: Kombinasi (gabungan) e-TeX dan upTeX.

#### Menghasilkan berkas sumber komposit untuk e-upTeX

Untuk membuat berkas sumber WEB komposit untuk e-upTeX (dengan SyncTeX) Anda memulai dengan `tex.web` Knuth tetapi perlu menerapkan **26** berkas perubahan individual, dalam urutan berikut, untuk menghasilkan satu berkas komposit dari mana daftar perintah primitif dapat diekstrak:

```
etex.ch, tex.ch0, tex.ch, tex.ech, etex.ch0,
ptex-base.ch, uptex-m.ch, euptex.ch0, eptex.ech,
etex.ch1, euptex.ch1, synctex-def.ch0, synctex-ep-mem.ch0,
synctex-mem.ch0, synctex-e-mem.ch0, synctex-ep-mem.ch1,
synctex-p-rec.ch0, synctex-rec.ch0, synctex-rec.ch1,
synctex-e-rec.ch0, synctex-p-rec.ch1, fam256.ch,
pdfstrcmp-eup-pre.ch, pdfutils.ch, pdfstrcmp-eup-post.ch,
tex-binpool.ch
```

#### Menerapkan berkas perubahan: berkas mana dan dalam urutan apa?

Seperti dicatat, sangat penting untuk menerapkan/memproses berkas perubahan dalam urutan yang ketat—tetapi bagaimana Anda mengetahui berkas mana yang diperlukan dan urutan pemrosesannya? Untungnya, informasi penting itu dicatat di dalam berkas-berkas yang terdapat dalam distribusi TeX Live dan penelusuran kode sumber TeX Live mengungkap aturan yang mengatur persyaratan pembangunan untuk setiap mesin TeX. Dengan mengikuti aturan-aturan itu Overleaf mampu merekonstruksi berkas sumber WEB komposit untuk tiap mesin TeX dan mengekstrak daftar primitif untuk pemrosesan data lanjutan.

## Dan akhirnya: Bagaimana mengekstrak daftar primitif?

Setelah berkas WEB komposit dibangun, tugas mengekstrak daftar primitif, menggunakan ekspresi reguler, menjadi langsung karena semua perintah primitif didefinisikan (“didaftarkan”) menggunakan satu fungsi Pascal bernama `primitive(...)`. Berikut beberapa contoh nyata yang diambil dari `tex.web` kode sumber Knuth:

```
primitive("lineskip",assign_glue,glue_base+line_skip_code)
primitive("baselineskip",assign_glue,glue_base+baseline_skip_code)
primitive("parskip",assign_glue,glue_base+par_skip_code)
primitive("abovedisplayskip",assign_glue,glue_base+above_display_skip_code)
primitive("belowdisplayskip",assign_glue,glue_base+below_display_skip_code)
primitive("abovedisplayshortskip",assign_glue,glue_base+above_display_short_skip_code)
...
...
```

Seperti yang Anda lihat, `primitive(...)` fungsi ini sangat cocok untuk pemrosesan teks dengan ekspresi reguler: nama primitif yang sedang didaftarkan berada dalam tanda kutip (`"..."`) bersama dengan data tambahan yang mengklasifikasikan perilaku tiap primitif (kami tidak akan membahas itu secara rinci). Setelah mengekstrak daftar primitif untuk tiap mesin, data itu diproses oleh beberapa skrip Lua untuk menghasilkan HTML yang berisi hasil dalam bentuk tabel.

### Kembali ke LuaTeX

Kami telah mencatat bahwa LuaTeX tidak menggunakan proses pembangunan yang persis sama dengan 8 mesin TeX lainnya. Setelah secara singkat membahas proses Web2C, konversi Pascal ke C, dan mekanisme berkas perubahan, kini kita dapat menjelaskan di mana LuaTeX berbeda: para pengembang LuaTeX memutuskan untuk meniadakan proses rumit konversi Pascal ke C—sebagaimana dicatat dalam [Panduan Referensi LuaTeX](http://www.pragma-ade.com/general/manuals/luatex):

> ...kerangka kerja kompilasinya adalah web2c dan kami tetap menggunakannya tetapi tanpa langkah dari Pascal ke C.

Mesin inti LuaTeX ditulis ulang dalam C yang berarti bahwa proses pembangunannya agak lebih standar dan tentu saja jauh lebih nyaman. Salah satu akibat yang berguna adalah bahwa primitif yang didukung LuaTeX dipisahkan dengan rapi ke dalam berkas sumber kode C tersendiri, yang sangat memudahkan tugas mengakses/mencantumkannya.

Secara ketat, kami juga perlu mencatat bahwa beberapa berkas sumber LuaTeX menggunakan varian metodologi pemrograman literat Knuth, yang disebut [CWEB](https://en.wikipedia.org/wiki/CWEB), yang berbasis C dan bukan Pascal.

### Bukan hanya berkas WEB: kode sumber lain juga diperlukan

Setelah menghasilkan berkas sumber WEB komposit untuk mesin TeX mana pun (kecuali LuaTeX), kode sumber Pascal harus diekstrak dan dikonversi ke kode C tetapi itu bukan keseluruhan solusi. Selain kode C yang dihasilkan dari sumber WEB (Pascal⮕C), sebagian besar mesin TeX juga bergantung pada (memerlukan) sejumlah berkas kode sumber tambahan (pustaka) yang biasanya ditulis dalam C—seperti [Kpathsea](https://www.tug.org/kpathsea/). Berkas sumber tambahan (pustaka) mengimplementasikan fungsi yang tidak perlu, atau tidak bisa, ditulis dalam WEB (Pascal). Apa pun yang ditulis dalam “bahasa” WEB untuk TeX harus menggunakan bahasa Pascal yang kemudian diekstrak dan dikonversi menjadi C yang dihasilkan mesin: jika Anda tidak perlu melakukan itu, mengapa tidak menuliskannya saja dalam C atau C++ sejak awal.


---

# 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/18-how-overleaf-created-the-tex-primitive-reference-data.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.