Instalasi Free Pascal dan Struktur Program Pascal

Setelah menyelesaikan modul ini, mahasiswa diharapkan mampu:

1. Memasang Free Pascal beserta IDE pada sistem operasi Windows, Linux, atau macOS.
2. Menjalankan perintah kompilasi fpc dari terminal maupun dari dalam IDE.
3. Menjelaskan alur kompilasi dari kode sumber .pas hingga berkas .exe.
4. Mengidentifikasi dan menuliskan tujuh bagian struktur program Pascal secara benar.
5. Membedakan kedudukan blok const, type, dan var di dalam program.
6. Menggunakan komentar dengan tiga gaya yang didukung Pascal.
7. Menjelaskan perbedaan mendasar Free Pascal dengan Turbo Pascal, termasuk mode kompilasi.
8. Menggunakan direktif kompilator sederhana seperti {$mode tp} dan {$H+}.
9. Membaca dan menafsirkan pesan kesalahan kompilator untuk memperbaiki kode secara sistematis.

Capaian Pembelajaran Mata Kuliah

Mahasiswa mampu menyiapkan lingkungan pengembangan Pascal, menulis program dengan struktur yang benar, mengompilasi, menjalankan, dan memecahkan masalah kompilasi dasar secara mandiri.

Indikator Ketercapaian Modul

3.1 Mengapa Free Pascal

Free Pascal Compiler (FPC) adalah kompiler Pascal modern yang bersifat open source dan tersedia gratis. Proyek ini dimulai pada 1993 oleh Florian Klämpfl dan kini mendukung berbagai platform: Windows, Linux, macOS, FreeBSD, dan beberapa arsitektur prosesor. Terdapat beberapa alasan FPC menjadi pilihan utama untuk pembelajaran:

• Gratis dan terbuka. Tidak ada batasan lisensi untuk penggunaan pendidikan maupun komersial.
• Lintas platform. Kode yang sama dapat dikompilasi di Windows, Linux, dan macOS.
• Kompatibel dengan Turbo Pascal. Mode {$mode tp} memungkinkan menjalankan kode lama hampir tanpa perubahan.
• Mendukung Object Pascal penuh. Penting untuk fase lanjutan pada Modul 36 hingga 50.
• Aktif dikembangkan. Rilis stabil dikeluarkan secara berkala dan komunitasnya masih hidup.

3.2 Pilihan Editor dan IDE

Anda dapat menulis Pascal dengan beberapa pilihan lingkungan kerja. Tidak ada yang paling benar, semuanya bergantung pada kenyamanan dan kebutuhan Anda.

3.3 Instalasi Free Pascal di Windows

Prosedur berikut berlaku untuk Windows 10 dan Windows 11. Estimasi waktu pemasangan sekitar 5 hingga 10 menit.

1. Unduh pemasang FPC. Buka freepascal.org/download.html, pilih platform Windows, lalu unduh berkas fpc-x.y.z.i386-win32.exe atau versi 64-bit fpc-x.y.z.x86_64-win64.exe. Untuk komputer modern, pilih versi 64-bit.
2. Jalankan pemasang. Klik dua kali berkas yang telah diunduh. Bila muncul peringatan User Account Control, pilih Yes. Pilih bahasa instalasi lalu klik OK.
3. Ikuti wizard instalasi. Terima lisensi, pilih folder instalasi (default C:\FPC\x.y.z sudah sesuai), dan pilih Full installation agar IDE dan dokumentasi tersedia.
4. Selesaikan instalasi. Klik Install dan tunggu hingga proses selesai. Pastikan opsi Add FPC to PATH tercentang bila tersedia.
5. Verifikasi dari Command Prompt. Buka Command Prompt baru, lalu jalankan:
   Command PromptShell

   fpc -iV

   Bila terpasang benar, akan muncul nomor versi, misalnya 3.2.2.

3.4 Instalasi Free Pascal di Linux

Di sebagian besar distribusi Linux, FPC tersedia di repositori resmi. Buka terminal dan jalankan perintah sesuai distribusi Anda.

sudo apt update
sudo apt install fpc

sudo dnf install fpc

sudo pacman -S fpc

Setelah pemasangan selesai, verifikasi dengan perintah fpc -iV. Untuk pengalaman grafis, Anda dapat menambahkan Lazarus melalui repositori distribusi atau mengunduh versi resmi dari lazarus-ide.org.

3.5 Instalasi Free Pascal di macOS

Pada macOS, ada dua jalur utama. Pertama, melalui paket resmi .dmg dari situs Free Pascal. Kedua, melalui Homebrew bagi pengguna yang sudah terbiasa dengan manajer paket tersebut.

brew install fpc

3.6 Alur Kompilasi Program Pascal

Memahami apa yang terjadi ketika Anda menekan tombol kompilasi akan sangat membantu ketika muncul kesalahan. Secara garis besar, kompiler Pascal menerjemahkan kode sumber menjadi program yang dapat dieksekusi melalui beberapa tahap.

flowchart LR
    A["Kode Sumber
program.pas"] --> B["Preprocessing
direktif kompilator"]
    B --> C["Analisis Leksikal
tokenisasi"]
    C --> D["Analisis Sintaks
pohon parsing"]
    D --> E["Analisis Semantik
cek tipe dan scope"]
    E --> F["Pembangkitan Kode
assembly"]
    F --> G["Assembler"]
    G --> H["Linker
menyatukan unit"]
    H --> I["Program
program.exe"]
      

Pada praktiknya, seluruh tahap di atas dipicu oleh satu perintah fpc nama_berkas.pas. Free Pascal juga menghasilkan berkas antara seperti .o (object) dan .ppu (unit), namun untuk keperluan pembelajaran, Anda cukup fokus pada berkas .pas sebagai input dan .exe (Windows) atau berkas tanpa ekstensi (Linux/macOS) sebagai output.

3.7 Struktur Lengkap Program Pascal

Program Pascal memiliki struktur bertingkat yang sangat ketat. Secara lengkap, ada tujuh bagian yang perlu Anda ketahui, meskipun sebagian di antaranya bersifat opsional.

program NamaProgram;                          { 1. Judul program }

uses NamaUnit1, NamaUnit2;                    { 2. Klausa uses }

const                                         { 3. Blok konstanta }
  KONSTANTA_1 = nilai;
  KONSTANTA_2 = nilai;

type                                          { 4. Blok tipe bentukan }
  NamaTipe = definisi;

var                                           { 5. Blok variabel global }
  variabel_1 : tipe;
  variabel_2 : tipe;

  procedure NamaProsedur;                     { 6. Subprogram (opsional) }
  begin
    { ... }
  end;

begin                                         { 7. Blok pernyataan utama }
  pernyataan;
  pernyataan;
end.

Berikut penjelasan setiap bagian.

3.8 Aturan Penulisan Sintaks

a. Titik koma dan titik

Pascal membedakan dengan jelas tiga jenis pemisah:

• Titik koma (;) memisahkan pernyataan di dalam blok.
• Titik dua (:) memisahkan nama variabel dari tipe datanya di blok deklarasi.
• Titik (.) hanya muncul sekali, yaitu setelah end terakhir program.

b. Titik koma sebelum end

Secara aturan, pernyataan terakhir sebelum end boleh tanpa titik koma. Namun, banyak programmer tetap menuliskannya untuk mencegah kesalahan saat menyisipkan pernyataan baru di kemudian hari. Kami menyarankan kebiasaan menuliskan titik koma di setiap akhir pernyataan.

c. Pemisah antar pernyataan dan antar blok

Perhatikan bahwa setelah end yang menutup blok begin...end di dalam program, diikuti titik koma. Namun setelah end yang menutup program secara keseluruhan, diikuti titik.

3.9 Komentar dalam Pascal

Pascal mendukung tiga gaya komentar. Ketiganya berfungsi sama, yaitu diabaikan oleh kompiler.

program TigaGayaKomentar;

{ Ini komentar gaya kurung kurawal.
  Dapat menempati beberapa baris sekaligus. }

(* Ini komentar gaya kurung bintang.
   Sering dipakai untuk memblok kode sementara. *)

// Ini komentar gaya garis miring ganda.
// Hanya berlaku sampai akhir baris.

begin
  writeln('Program ini mendemonstrasikan tiga gaya komentar.');
end.

3.10 Direktif Kompilator

Direktif kompilator adalah perintah khusus yang disampaikan kepada kompiler, bukan kepada program yang dihasilkan. Sintaksnya sama dengan komentar, yaitu di dalam { ... }, tetapi diawali karakter dolar $.

Direktif ditulis pada baris tersendiri, biasanya di bagian atas program sebelum deklarasi. Contoh penggunaannya:

{$mode tp}
{$R+}

program ContohDirektif;

var
  nilai: integer;

begin
  write('Masukkan nilai: ');
  readln(nilai);
  writeln('Nilai yang Anda masukkan: ', nilai);
end.

3.11 Perbedaan Free Pascal dan Turbo Pascal

Pemahaman terhadap perbedaan ini penting ketika Anda menemukan referensi atau kode lama dari era Turbo Pascal.

3.12 Membaca Pesan Kesalahan Kompilator

Kompiler Free Pascal melaporkan kesalahan dalam format yang teratur:

nama_berkas.pas(baris, kolom) Error: pesan kesalahan
nama_berkas.pas(baris, kolom) Warning: pesan peringatan
nama_berkas.pas(baris, kolom) Fatal: kesalahan yang menghentikan kompilasi
nama_berkas.pas(baris, kolom) Note: catatan informasi

Empat tingkat keparahan yang perlu Anda ketahui:

1. Note — informasi saja, tidak menghentikan kompilasi.
2. Warning — ada masalah yang sebaiknya diperbaiki, tetapi program masih dapat dikompilasi.
3. Error — ada kesalahan yang mencegah kompilasi. Program tidak dihasilkan.
4. Fatal — kesalahan serius yang menghentikan proses lebih awal, sering kali karena berkas tidak ditemukan.

Berikut beberapa pesan kesalahan yang paling sering muncul.

Flowchart pada bagian ini menggambarkan alur kerja yang akan Anda lakukan berulang-ulang sepanjang kursus: menulis kode, mengompilasi, memperbaiki kesalahan, menjalankan, dan menguji.

4.1 Flowchart Siklus Menulis-Kompilasi-Jalankan

flowchart TD
    A(["Mulai"]) --> B["Tulis atau ubah
kode sumber .pas"]
    B --> C["Jalankan perintah
fpc nama_berkas.pas"]
    C --> D{"Kompilasi
berhasil?"}
    D -- "Tidak" --> E["Baca pesan kesalahan
di terminal"]
    E --> F["Identifikasi baris
dan jenis kesalahan"]
    F --> G["Perbaiki kode sumber"]
    G --> B
    D -- "Ya" --> H["Jalankan
program hasil kompilasi"]
    H --> I{"Hasil sesuai
yang diharapkan?"}
    I -- "Tidak" --> J["Analisis logika
dan data uji"]
    J --> B
    I -- "Ya" --> K(["Selesai"])
      

4.2 Flowchart Alur Kompilasi Berkas .pas Menjadi .exe

Diagram berikut memperlihatkan secara lebih teknis apa yang terjadi di dalam kompiler FPC ketika Anda menjalankannya.

flowchart TD
    A(["Perintah fpc dijalankan"]) --> B["Baca berkas sumber .pas"]
    B --> C{"Berkas
ditemukan?"}
    C -- "Tidak" --> X["Fatal: can't open file"]
    X --> Z(["Selesai dengan kesalahan"])
    C -- "Ya" --> D["Proses direktif kompilator"]
    D --> E["Analisis leksikal dan sintaks"]
    E --> F{"Ada kesalahan
sintaks?"}
    F -- "Ya" --> Y["Tampilkan pesan error"]
    Y --> Z
    F -- "Tidak" --> G["Analisis semantik dan tipe"]
    G --> H{"Ada kesalahan
tipe atau scope?"}
    H -- "Ya" --> Y
    H -- "Tidak" --> I["Bangkitkan kode objek .o"]
    I --> J["Link dengan unit yang dipakai"]
    J --> K["Hasilkan berkas .exe"]
    K --> L(["Selesai dengan sukses"])
      

Karena modul ini lebih menekankan aspek persiapan lingkungan dan struktur, pseudocode yang disajikan berbentuk algoritma prosedural yang menggambarkan langkah-langkah instalasi dan kompilasi.

5.1 Pseudocode Memasang dan Memverifikasi Free Pascal

PROGRAM VerifikasiInstalasiFPC
{ Memastikan Free Pascal terpasang dan dapat dipanggil dari terminal }

DEKLARASI
  versiFPC : string

ALGORITMA
  write("Membuka terminal atau Command Prompt...")
  write("Menjalankan perintah: fpc -iV")
  read(versiFPC)

  jika versiFPC kosong maka
    write("Free Pascal belum terpasang atau tidak ada di PATH.")
    write("Periksa kembali langkah instalasi.")
  selain itu
    write("Free Pascal terpasang dengan versi: ", versiFPC)
    write("Instalasi berhasil.")
  akhir jika
END

5.2 Pseudocode Mengompilasi dan Menjalankan Program

PROGRAM KompilasiDanJalankan
{ Alur mengompilasi berkas .pas dan menjalankan hasilnya }

DEKLARASI
  namaBerkas    : string
  berhasil      : boolean

ALGORITMA
  write("Nama berkas sumber (tanpa ekstensi): ")
  read(namaBerkas)

  write("Menjalankan: fpc ", namaBerkas, ".pas")
  berhasil <- jalankanKompilasi(namaBerkas)

  jika berhasil = false maka
    write("Kompilasi gagal. Baca pesan kesalahan di layar.")
    write("Perbaiki kode sumber lalu ulangi.")
  selain itu
    write("Kompilasi berhasil. Menjalankan program...")
    jalankanProgram(namaBerkas)
  akhir jika
END

5.3 Pseudocode Struktur Program Sederhana

PROGRAM StrukturProgramContoh
{ Mendemonstrasikan urutan blok deklarasi dan pernyataan }

KONSTANTA
  BATAS_MAKS = 100

DEKLARASI
  nilaiAktual : integer
  namaProgram : string

ALGORITMA
  namaProgram <- "StrukturProgramContoh"
  write("Nama program: ", namaProgram)

  nilaiAktual <- BATAS_MAKS
  write("Nilai batas maksimum: ", nilaiAktual)
END

6.1 Program Minimal: Struktur Paling Sederhana

Program berikut adalah bentuk paling minimal dari program Pascal yang sah. Baris judul dan deklarasi dihilangkan, hanya menyisakan blok utama.

begin
  writeln('Program Pascal paling minimal.');
end.

Program ini tidak memiliki judul, tidak memakai variabel, dan tidak menerima masukan. Namun, program ini sudah lengkap dan dapat dikompilasi serta dijalankan.

6.2 Program dengan Struktur Lengkap

Program berikut mendemonstrasikan semua bagian struktur Pascal kecuali subprogram: judul, klausa uses, blok const, blok type, blok var, dan blok utama.

program StrukturLengkap;
{ Mendemonstrasikan struktur lengkap program Pascal
  tanpa subprogram }

uses
  crt;

const
  NAMA_APLIKASI = 'Demo Struktur Pascal';
  VERSI = '1.0.0';
  TAHUN = 2025;

type
  Suhu = -100..100;

var
  namaPengguna: string;
  umur: integer;
  suhuRuang: Suhu;
  sudahLogin: boolean;

begin
  clrscr;

  writeln('==========================================');
  writeln(NAMA_APLIKASI);
  writeln('Versi ', VERSI, ' - Tahun ', TAHUN);
  writeln('==========================================');
  writeln;

  write('Siapa nama Anda? ');
  readln(namaPengguna);
  write('Berapa umur Anda? ');
  readln(umur);
  write('Suhu ruangan (Celsius, -100 s.d. 100)? ');
  readln(suhuRuang);

  sudahLogin := true;

  writeln;
  writeln('==========================================');
  writeln('Ringkasan Data');
  writeln('==========================================');
  writeln('Nama       : ', namaPengguna);
  writeln('Umur       : ', umur, ' tahun');
  writeln('Suhu ruang : ', suhuRuang, ' derajat Celsius');
  writeln('Status     : ', sudahLogin);
  writeln('==========================================');
end.

Contoh keluaran:

==========================================
Demo Struktur Pascal
Versi 1.0.0 - Tahun 2025
==========================================

Siapa nama Anda? Andi
Berapa umur Anda? 20
Suhu ruangan (Celsius, -100 s.d. 100)? 24

==========================================
Ringkasan Data
==========================================
Nama       : Andi
Umur       : 20 tahun
Suhu ruang : 24 derajat Celsius
Status     : TRUE
==========================================

6.3 Program dengan Direktif Kompilator Mode Turbo Pascal

Program ini menambahkan direktif {$mode tp} di baris paling atas agar perilaku kompilasi menyerupai Turbo Pascal. Perhatikan bahwa string maksimal 255 karakter pada mode ini.

{$mode tp}
{$R+}

program ModeTurboPascal;
{ Mendemonstrasikan penggunaan direktif kompilator }

const
  MAKS_NILAI = 100;
  MIN_NILAI = 0;

var
  namaSiswa: string[30];
  nilai: integer;

begin
  write('Nama siswa (maks 30 karakter): ');
  readln(namaSiswa);

  write('Nilai ujian (0 sampai 100): ');
  readln(nilai);

  writeln;
  writeln('Nama  : ', namaSiswa);
  writeln('Nilai : ', nilai);

  if (nilai >= MIN_NILAI) and (nilai <= MAKS_NILAI) then
    writeln('Status: Nilai valid')
  else
    writeln('Status: Nilai di luar rentang yang diizinkan');
end.

6.4 Program dengan Subprogram Sederhana

Sebagai pratinjau Modul 11, program berikut menambahkan satu prosedur sederhana. Perhatikan bahwa prosedur harus dideklarasikan sebelum blok utama.

program DenganProsedur;
{ Pratinjau subprogram: prosedur sederhana }

const
  GARIS = '==========================================';

var
  nama: string;

procedure TampilkanHeader;
begin
  writeln(GARIS);
  writeln('  Program dengan Subprogram Sederhana');
  writeln(GARIS);
end;

procedure SapaPengguna(namaSapa: string);
begin
  writeln('Selamat datang, ', namaSapa, '!');
end;

begin
  TampilkanHeader;

  write('Siapa nama Anda? ');
  readln(nama);

  SapaPengguna(nama);

  writeln('Prosedur selesai dijalankan.');
  writeln(GARIS);
end.

Program ini menunjukkan tiga hal penting: (1) subprogram dideklarasikan setelah blok var dan sebelum blok utama, (2) prosedur dapat dipanggil dari blok utama, (3) konstanta yang dideklarasikan di tingkat program dapat diakses dari dalam prosedur.

7.1 Program StrukturLengkap

7.2 Program ModeTurboPascal

7.3 Jejak Eksekusi Program StrukturLengkap

Tabel berikut menunjukkan jejak eksekusi program StrukturLengkap dengan masukan nama = Andi, umur = 20, suhu = 24.

9.1 Deskripsi Masalah

Sebuah lembaga kursus pemrograman menerima pendaftaran peserta melalui program sederhana. Setiap peserta diminta memasukkan data berikut: nama lengkap, usia, asal kota, dan pilihan bahasa pemrograman. Program akan menampilkan kembali data tersebut dalam bentuk kartu peserta, lengkap dengan nomor urut otomatis.

Studi kasus ini melatih penggunaan lengkap struktur program: konstanta, tipe bentukan, variabel, dan blok utama dengan masukan serta keluaran terformat.

9.2 Analisis dengan Berpikir Komputasional

9.3 Flowchart Studi Kasus

flowchart TD
    A(["Mulai"]) --> B[/"Baca nama, usia, kota, pilihan bahasa"/]
    B --> C["Susun nomor peserta = 1"]
    C --> D["Siapkan garis pemisah dari konstanta"]
    D --> E[/"Tampilkan kartu peserta"/]
    E --> F(["Selesai"])
      

9.4 Pseudocode Studi Kasus

PROGRAM KartuPesertaPelatihan
{ Menerima data peserta dan menampilkan kartu pendaftaran }

KONSTANTA
  NAMA_LEMBAGA = "Lembaga Kursus Pemrograman Nusantara"
  GARIS_GANDA  = "=========================================="
  GARIS_TUNGGAL= "------------------------------------------"

TIPE
  UsiaPeserta = 10..80

DEKLARASI
  namaPeserta    : string
  usia           : UsiaPeserta
  asalKota       : string
  bahasaPilihan  : string
  nomorPeserta   : integer

ALGORITMA
  nomorPeserta <- 1

  write("Nama lengkap      : ")
  read(namaPeserta)
  write("Usia              : ")
  read(usia)
  write("Asal kota         : ")
  read(asalKota)
  write("Bahasa pemrograman: ")
  read(bahasaPilihan)

  write(GARIS_GANDA)
  write(NAMA_LEMBAGA)
  write(GARIS_GANDA)
  write("Nomor Peserta     : ", nomorPeserta)
  write("Nama              : ", namaPeserta)
  write("Usia              : ", usia, " tahun")
  write("Asal Kota         : ", asalKota)
  write("Bahasa Pilihan    : ", bahasaPilihan)
  write(GARIS_TUNGGAL)
  write("Status            : TERDAFTAR")
  write(GARIS_GANDA)
END

9.5 Implementasi dalam Pascal

program KartuPesertaPelatihan;
{ Studi Kasus Modul 2 - Kartu pendaftaran peserta pelatihan }

const
  NAMA_LEMBAGA  = 'Lembaga Kursus Pemrograman Nusantara';
  GARIS_GANDA   = '==========================================';
  GARIS_TUNGGAL = '------------------------------------------';

type
  UsiaPeserta = 10..80;

var
  namaPeserta   : string;
  usia          : UsiaPeserta;
  asalKota      : string;
  bahasaPilihan : string;
  nomorPeserta  : integer;

begin
  nomorPeserta := 1;

  writeln('Formulir Pendaftaran Peserta');
  writeln(GARIS_TUNGGAL);
  writeln;

  write('Nama lengkap      : ');
  readln(namaPeserta);

  write('Usia (10-80)      : ');
  readln(usia);

  write('Asal kota         : ');
  readln(asalKota);

  write('Bahasa pemrograman: ');
  readln(bahasaPilihan);

  writeln;
  writeln(GARIS_GANDA);
  writeln(NAMA_LEMBAGA);
  writeln(GARIS_GANDA);
  writeln('Nomor Peserta     : ', nomorPeserta);
  writeln('Nama              : ', namaPeserta);
  writeln('Usia              : ', usia, ' tahun');
  writeln('Asal Kota         : ', asalKota);
  writeln('Bahasa Pilihan    : ', bahasaPilihan);
  writeln(GARIS_TUNGGAL);
  writeln('Status            : TERDAFTAR');
  writeln(GARIS_GANDA);
end.

9.6 Contoh Keluaran

Formulir Pendaftaran Peserta
------------------------------------------

Nama lengkap      : Siti Nurhaliza
Usia (10-80)      : 22
Asal kota         : Bandung
Bahasa pemrograman: Pascal

==========================================
Lembaga Kursus Pemrograman Nusantara
==========================================
Nomor Peserta     : 1
Nama              : Siti Nurhaliza
Usia              : 22 tahun
Asal Kota         : Bandung
Bahasa Pilihan    : Pascal
------------------------------------------
Status            : TERDAFTAR
==========================================

9.7 Pembahasan

Perhatikan keputusan perancangan berikut.

1. Konstanta untuk garis pemisah. Alih-alih menuliskan '=====' berkali-kali, kita definisikan sekali sebagai GARIS_GANDA dan GARIS_TUNGGAL. Bila nanti ingin mengubah panjang garis, cukup satu tempat yang diubah.
2. Tipe subrange untuk usia. Dengan mendefinisikan UsiaPeserta = 10..80, kita menyatakan secara eksplisit rentang usia yang sah. Bila nanti ditambahkan direktif {$R+}, kompiler akan memvalidasi masukan secara otomatis.
3. Blok keluaran terstruktur. Setiap baris kartu ditulis dengan writeln tunggal. Ini membuat kode mudah dibaca dan dimodifikasi.
4. Pemisah visual. Menyisipkan writeln; tanpa argumen memisahkan formulir dari kartu hasil dengan rapi.

9.8 Pengembangan Selanjutnya

Program ini akan berkembang pada modul-modul berikutnya.

1. Free Pascal adalah kompiler Pascal modern, gratis, open source, dan lintas platform. Tersedia untuk Windows, Linux, dan macOS.
2. Pemasangan FPC dapat dilakukan melalui pemasang grafis di Windows, manajer paket di Linux, dan Homebrew atau paket .dmg di macOS. Verifikasi dengan perintah fpc -iV.
3. Alur kompilasi melibatkan analisis leksikal, sintaks, semantik, pembangkitan kode, assembling, dan linking. Satu perintah fpc nama_berkas.pas menjalankan seluruh tahap tersebut.
4. Struktur program Pascal terdiri atas tujuh bagian: judul program, klausa uses, blok const, blok type, blok var, subprogram, dan blok utama. Urutannya bersifat mengikat.
5. Titik koma memisahkan pernyataan; titik dua memisahkan nama variabel dari tipe; titik hanya muncul sekali, setelah end penutup program.
6. Pascal mendukung tiga gaya komentar: { ... }, (* ... *), dan // ... (khusus FPC dan Delphi). Komentar gaya kurawal tidak dapat disarangkan.
7. Direktif kompilator ditulis dalam { $... }. Yang paling penting: {$mode tp}, {$mode delphi}, {$mode objfpc}, dan {$R+}.
8. Perbedaan utama Free Pascal dan Turbo Pascal terletak pada arsitektur (16-bit vs 32/64-bit), dukungan Object Pascal, tipe string default, dan ketersediaan saat ini.
9. Pesan kesalahan kompilator memiliki empat tingkat: Note, Warning, Error, dan Fatal. Bila pesan menunjuk baris tertentu, periksa juga baris sebelumnya karena penyebab sering ada di sana.
10. Bila ingin perilaku semirip mungkin dengan Turbo Pascal, gunakan {$mode tp}. Bila ingin memanfaatkan fitur modern seperti string dinamis dan class, gunakan {$mode objfpc} atau {$mode delphi}.

Buku Teks

1. Wirth, N. (1971). "The Programming Language Pascal." Acta Informatica, 1(1), 35-63. Makalah asli yang mendefinisikan bahasa Pascal.
2. Jensen, K., & Wirth, N. (1991). Pascal User Manual and Report (4th ed.). Springer-Verlag. Referensi standar definisi Pascal.
3. Cooper, D., & Clancy, M. (1982). Oh! Pascal! W. W. Norton & Company. Buku pengantar klasik yang sangat baik untuk pemula.
4. Cantu, M. (2020). Object Pascal Handbook. Marco Cantu. Referensi modern untuk Free Pascal dan Delphi.
5. Grogono, P. (1995). Programming with Pascal. Addison-Wesley. Buku teks akademik yang membahas struktur program secara rinci.

Dokumentasi Resmi

1. Free Pascal Team. Free Pascal Programmer's Guide. Tersedia di freepascal.org/docs.html.
2. Free Pascal Team. Free Pascal Reference Guide. Berisi daftar lengkap reserved words, direktif kompilator, dan tipe data standar.
3. Free Pascal Team. Free Pascal User's Guide. Berisi petunjuk instalasi untuk berbagai platform.
4. Lazarus IDE Documentation. Tersedia di wiki.lazarus.freepascal.org.

Sumber Daring

1. Free Pascal Official Website. https://www.freepascal.org.
2. Lazarus IDE Official Website. https://www.lazarus-ide.org.
3. Pascal Central. Kumpulan sumber daya, tutorial, dan referensi Pascal.
4. Stack Overflow - Tag pascal dan freepascal. Komunitas tanya-jawab yang aktif untuk permasalahan praktis.