MAKALAH TUGAS TEKNIK KOMPILASI “PEMBUATAN SCANNER UNTUK

BAHASA PEMROGRAMAN PASCAL DENGAN MENGGUNAKAN BAHASA

PEMROGRAMAN C PADA SOFTWARE DEV-C++”

DISUSUN OLEH NAMA: FADHILAH ATIKA NIM: 131401143 KOM: B

PROGRAM STUDI S1 ILMU KOMPUTER FAKULTAS ILMU KOMPUTER DAN

TEKNOLOGI INFORMASI

UNIVERSITAS SUMATERA UTARA

MEDAN

2016

KATA PENGANTAR
Puji dan syukur penulis panjatkan ke hadirat Allah SWT, karena atas rahmat-Nya sehingga penulis
dapat menyelesaikan makalah ini sesuai dengan batas waktu yang telah ditentukan. Adapun
makalah ini berjudul “PEMBUATAN SCANNER UNTUK BAHASA PEMROGRAMAN
PASCAL DENGAN MENGGUNAKAN BAHASA PEMROGRAMAN C PADA
SOFTWARE DEV-C++” yang merupakan salah satu tugas dari dosen mata kuliah Teknik
Kompilasi, yaitu Ibu Amalia, ST, MT.

Makalah ini telah penulis susun dengan maksimal dan mendapatkan bantuan dari berbagai
pihak sehingga dapat memperlancar pembuatan makalah ini. Untuk itu penulis menyampaikan
banyak terima kasih kepada semua pihak yang telah berkontribusi dalam pembuatan makalah ini.

Terlepas dari semua itu, penulis menyadari sepenuhnya bahwa masih ada kekurangan baik dari
segi susunan kalimat maupun tata bahasanya. Oleh karena itu dengan tangan terbuka menerima
segala saran dan kritik dari pembaca demi perbaikan makalah ini ke depannya. Akhir kata penulis
berharap semoga makalah ini dapat bermanfaat dan menambah wawasan bagi pembaca dan
khususnya bagi penulis juga.

Medan, 25 Maret 2016

Penulis,

Fadhilah Atika
Nim: 131401143
 i

DAFTAR ISI

KATA PENGANTAR ....................................................................................................................1

DAFTAR ISI ...................................................................................................................................3

BAB 1 DASAR TEORI ..................................................................................................................1

A. ANALISIS LEKSIKAL ........................................................................................................1

B. POSISI ANALISIS LEKSIKAL DALAM POSISI COMPILER ......................................7

BAB 2 PERANCANGAN ANALISIS LEKSIKAL ...................................................................10

A. BAHASA PEMROGRAMAN YANG DIGUNAKAN .....................................................10

B. BAHASA SUMBER UNTUK DIANALISA (PASCAL) .................................................10
C. PENENTUAN NAMA TOKEN YANG DIPILIH ............................................................11
KOMENTAR ....................................................................................................................12
I. HAPUS WHITE SPACE ..............................................................................................12
II. HAPUS KOMENTAR .................................................................................................13
EXPRESSION) DAN FSA (FINITE STATE AUTOMATA) ..........................................13
I. RE (REGULAR EXPRESSION) ..................................................................................13
II. FSA (FINITE STATE AUTOMATA)..........................................................................17
BAB 3 SCREEN SHOT OUTPUT PROGRAM ........................................................................24

BAB 4 KESIMPULAN .................................................................................................................27

BAB 5 SOURCE PROGRAM ......................................................................................................27

DAFTAR PUSTAKA ...................................................................................................................38

D. ALGORITMA/FLOWCHART UNTUK HAPUS WHITE SPACE DAN HAPUS

E. ALGORITMA/FLOWCHART TAHAPAN PENGERJAAN RE
(REGULAR
ii
 BAB 1 DASAR TEORI

A. ANALISIS LEKSIKAL

Analisis Leksikal/Analisis Linier/Pembacaan Sekilas (Scanner). Dalam kaitan ini

aliran karakter yang membentuk program sumber dibaca dari kiri ke kanan dan dikelompokkan
dalam apa yang disebut token yaitu barisan dari karakter yang dalam suatu kesatuan
mempunyai suatu arti tersendiri.
Analisis ini melakukan penerjemahan masukan menjadi bentuk yang lebih berguna
untuk tahap-tahap kompilasi berikutnya. Analisis Leksikal merupakan antarmuka antara kode
program sumber dan analisis sintaktik (parser). Scanner melakukan pemeriksaan karakter per
karakter pada teks masukan, memecah sumber program menjadi bagian-bagian disebut Token.
Analisis Leksikal mengerjakan pengelompokkan urutan-urutan karakter ke dalam komponen
pokok: identifier, delimeter, simbol-simbol operator, angka, keyword, noise word, blank,
komentar, dan seterusnya menghasilkan suatu Token Leksikal yang akan digunakan pada
Analisis Sintaktik.
Model dasar untuk membentuk suatu Analisis Leksikal adalah Finite-State Automata,
2 aspek penting pembuatan Analisis Leksikal adalah:
 Menentukan token-token bahasa.
 Mengenali token-token bahasa dari program sumber.
Token-token dihasilkan dengan cara memisahkan program sumber tersebut dilewatkan
ke parser. Analisis Leksikal harus mengirim token ke parser. Untuk mengirim token, scanner
harus mengisolasi barisan karakter pada teks sumber yang merupakan 1 token valid. Scanner
juga menyingkirkan informasi seperti komentar, blank, batas-batas baris dan lain-lain yang
tidak penting (tidak mempunyai arti) bagi parsing dan Code Generator.
Scanner juga harus dapat mengidentifikasi token secara lengkap dan membedakan
keyword dan identifier. Untuk itu scanner memerlukan tabel simbol. Scanner memasukkan
identifier ke tabel simbol, memasukkan konstanta literal dan numerik ke tabel simbol sendiri
setelah konversi menjadi bentuk internal.
Analisis Leksikal merupakan komponen kompilasi independen yang berkomunikasi
dengan parser lewat antarmuka yang terdefinisi bagus dan sederhana sehingga pemeliharaan
analisis leksikal menjadi lebih mudah dimana perubahan-perubahan terhadap analisis leksikal

1
tidak berdampak pada pengubahan kompilator secara keseluruhan. Agar dapat memperoleh
fitur ini, maka antarmuka harus tidak berubah. Kebanyakan kode yang menyusun analisis
leksikal adalah sama untuk seluruh kompilator, tidak peduli bahasa.

Pada analisis leksikal yang dituntun tabel (table-driven lexical analyzer), maka satu-
satunya yang berubah adalah tabel itu sendiri. Kadang diperlukan interaksi analisis leksikal
dan analisis sintaktik yang lebih kompleks. Sehingga analisis leksikal harus dapat menganggap
string sebagai token bertipe, bukan identifier. Untuk itu perlu komunikasi
tingkat lebih tinggi yang biasanya dilakukan suatu struktur data dipakai bersama seperti
tabel simbol. Analisis Sintaktik dapat memasukkan string ke tabel simbol, mengidentifikasi
sebagai Type atau typedef, sehingga analisis leksikal dapat memeriksa tabel simbol untuk
menentukan apakah lexeme adalah tipe token atau identifier.
Dari fungsi scanner secara umum seperti telah disebutkan di atas, maka tugas scanner
secara rinci adalah:
1. membaca serangkaian karakter dari source code
2. mengenalinya ke dalam satuan leksikal
3. mengubahnya menjadi token dan menentukan jenis token-nya.
4. mengirimkan token ke proses analisis selanjutnya, yaitu analisis sintaksis
5. mengabaikan karakter white space (spasi, enter, ganti baris, penanda akhir file)
dan komentar (remark) apabila ada di dalam source code
6. menangani error
7. menangani tabel symbol

2
 2.3 Tugas-tugas tambahan Analisis Leksikal

Tugas-tugas tambahan Analisis Leksikal antara lain sebagai berikut :

Penghilangan komentar dan whitespace (tab,spasi,karakter lainnya).Tindakan

housekeeping dilakukan scanner sehingga mengisolasikan dari parser dan komponen-
komponen kompilator lain.

Peran ini menyederhanakan perancangan parser (dan grammar bahasa

pemrograman). Scanner juga mencatat nomor baris saat itu sehingga penanganan kesalahan
yang cerdas dapat mengirim pesan kesalahan dengan lebih akurat.

Konversi literal/konstanta numerik menjadi tipe data tertentu. Analisis leksikal dapat
mengirim token, dan nilainya. Nilai ini biasa disebut atribut. Namun demikian, bila analisis
leksikal ditambahin dengan tugas-tugas tambahan yang terlalu banyak juga akan menjadi
tidak baik. Karena itu membatasi analisis

leksikal hanya untuk melakukan tugas pengenalan pola token (ditambah membuang
komentar) adalah mempermudah pemeliharaan.

2.4 Tahap-tahap Pelaksanaan Analisis Leksikal

Tahap Pelaksanaan Analisis Leksikal antara lain sebagai berikut :

Pada single one pass.

Terjadi interaksi antara scanner dan parser. Sacnner dipanggil saat parser
memerlukan token berikutnya. Pendekatan ini lebih baik karena bentuk internal program
sumber yang lengkap tidak perlu dibangun dan disimpan di memori sebelum parsing
dimulai.

Pada separate pass.

Scanner memproses secara terpisah, dilakukan sebelum parsing. Hasil scanner

disimpan dalam file. Dari file tersebut, parsing melakukan kegiatannya.

3
 Scanner mengirim nilai-nilai integer yang mempresentasikan bentuk internal token,
bukan nilai-nilai string.

Keunggulan cara ini adalah ukurannya kecil dan tetap. Parser sangat lebih efisien
bekerja dengan nilai integer yang mempresentasikan simbol daripada string nyata dengan
panjang variabel.

2.5 Implementasi Analisis Leksikal

Implementasi Analisis Leksikal antara lain sebagai berikut :

 Pengenalan Token.

Scanner harus dapat mengenali token

Terlebih dahulu dideskripsikan token-token yang harus dikenali

Pendeskripsian Token.

Menggunakan reguler grammar. Menspesifikasikan aturan-aturan pembangkit token-

token dengan kelemahan reguler grammar

menspesifikasikan token berbentuk pembangkit, sedang scanner perlu bentuk

pengenalan.

Menggunakan ekspresi grammar. Menspesifikasikan token-token dengan ekspresi

reguler.

Model matematis yang dapat memodelkan pengenalan adalah finite-state acceptor

(FSA) atau finite automata.

Implementasi Analisis Leksikal sebagai Finite Automata.

Pada pemodelan analisis leksikal sebagai pengenal yang menerapkan finite automata,
analisis leksikal tidak cuma hanya melakukan mengatakan YA atau TIDAK. Dengan
demikian selain pengenal, maka analisis leksikal juga melakukan aksi-aksi tambahan yang
diasosiasikan dengan string yangsedang diolah.

Analisis leksikal dapat dibangun dengan menumpangkan pada konsep pengenal yang
berupa finite automata dengan cara menspesifikasikan rutin-rutin (aksi-aksi) tertentu
terhadap string yang sedang dikenali.

4
 Penanganan Kesalahan di Analisis Leksikal Hanya sedikit kesalahan yang
diidentifikasi di analisis leksikal secara mandiri karena analisis leksikal benar-benar
merupakan pandangan sangat lokal terhadap program sumber.

Bila ditemui situasi dimana analisis leksikal tidak mampu melanjutkan proses karena
tidak ada pola token yang cocok, maka terdapat beragam alternatif pemulihan. yaitu:

"Panic mode" dengan menghapus karakter-karakter berikutnya sampai analisis

leksikal menemukan token yang terdefinisi bagus

Menyisipkan karakter yang hilang

Mengganti karakter yang salah dengan karakter yang benar

Mentransposisikan 2 karakter yang bersebelahan.

Salah satu cara untuk menemukan kesalahan-kesalahan di program adalah

menghitung jumlah transformasi kesalahan minimum yang diperlukan untuk
mentransformasikan program yang salah menjadi program yag secara sintaks benar.

Scanner bekerja berdasarkan prinsip mesin finite state automata (FSA). Diagram
keadaan dapat digunakan untuk membantu mengkonstruksi scanner.

Besaran pembangun bahasa (leksikal) meliputi:

a. Identifier
Identifier atau pengenal dapat berupa:
1. kata tercadang atau kata kunci (reserve word) yang telah didefinisikan oleh
bahasa pemrograman.
2. kata yang dideklarasikan sendiri oleh pemakai (si pembuat program) disebut
dengan variabel.

Contoh (dalam bahasa Pascal) var

nama : string; alamat : string j;
umlah_anak : byte;
nominal_tabungan : real;

begin clrscr;
end.

5
Dari contoh di atas, maka identifier yang dideklarasikan sendiri oleh pemakai
(variabel) adalah: nama, alamat, jumlah_anak, dan nominal_tabungan. Sedangkan
identifier kata tercadang (reserve word) adalah: var, string, byte, real, begin, clrscr,
dan end. Selain contoh yang disebutkan di atas, masih banyak kata tercadang yang
lainnya.

Untuk mendeklarasikan identifier oleh pemakai setiap bahasa pemrograman

memiliki aturan yang berbeda-beda, demikian juga dengan identifier kata tercadang
memiliki nama dan arti yang berbeda untuk setiap bahasa pemrograman.

Contoh begin dan end di bahasa Pascal → kata tercadang di

bahasa C → boleh digunakan untuk nama variabel
{ dan } di bahasa Pascal → ‘kata’ lebih tepatnya delimiter atau pembatas
untuk memberikan komentar pada kode sumber.
di bahasa C → delimiter untuk mengawali dan mengakhiri sebuah
blok program

b. Nilai konstanta
Nilai konstanta disini dapat berupa: integer, real, boolean, character, string, dan
sebagainya. Melalui contoh berikut ini, bedakan antara nilai (atau isi) dengan
variabel yang digunakan untuk menyimpannya.

Contoh (dalam bahasa Pascal)

6
 hitung_luas := panjang * lebar; x :=
1000; ulang := false; luas_lingkaran
:= 3.14 * jejari * jejari; nama := budi
hartono;

Dari contoh di atas, maka: 1000, false, 3.14, ’budi hartono’ termasuk besaran
leksikal berupa nilai konstanta. Sedangkan hirung_luas, panjang, lebar, x,
ulang, luas_lingkaran, jejari, dan nama termasuk besaran leksikal identifier
variable.

c. Operator dan Delimineter

1. Operator aritmatika ( +, -, *, /)
2. Operator rasional (<, =, >, <=, >=, !=, <>)
3. Delimiter berguna sebagai pemisah atau pembatas, contoh:
Karakter sebagai berikut ( ) { } ; . , :
4. Karakter white space, antara lain:
karakter spasi yang memisahkan token satu dan yang lain
• karakter spasi → kode ASCII 32
• karakter enter (carriage return) → kode ASCII 13
• karakter ganti baris (line feed)
• karakter penanda akhir file (end of file)

B. POSISI ANALISIS LEKSIKAL DALAM POSISI COMPILER

Kompilator (compiler) adalah sebuah program yang membaca suatu program yang
ditulis dalam suatu bahasa sumber (source language) dan menterjemah-kannya ke dalam suatu
bahasa sasaran (target language).

Proses kompilasi dikelompokan ke dalam dua kelompok besar:

1. Tahap Analisa (Front-end)

7
 • Menganalisis source code dan memecahnya menjadi bagian-bagian dasarnya.
• Menghasilkan kode level menengah dari source code input yang ada.
2. Tahap Sintesa (Back-end)
Membangun program sasaran yang diinginkan dari bentuk antara.

Tahap-tahap yang harus dilalui pada saat mengkompilasi program, yaitu:

1. Analisa Leksikal
2. Analisa Sintaks: Tahap analisa (front-end)
3. Analisa Semantik
4. Pembangkit Kode Antara
5. Code optimization: Tahap sintesa (back-end)
6. Object code generation

Keterangan :
• Analisa Leksikal (scanner)
Berfungsi memecah teks program sumber menjadi bagian-bagian kecil yang mempunyai satu
arti yang disebut token, seperti : konstanta, nama variabel, keyword, operator.
• Analisa Sintaks(parser)

8
 Berfungsi mengambil program sumber (sudah dalam bentuk barisan token) dan menentukan
kedudukan masing-masing token berdasarkan aturan sintaksnya dan memeriksa kebenaran dan
urutan kemunculan token.
• Analisa Semantik
Berfungsi menentukan validitas semantiks/keberartian program sumber. Biasanya bagian ini
digabung dengan Pembangkit kode antara (intermediate code generator).
• Pembangkit Kode Antara
Berfungsi membangkitkan kode antara.
• Code generator
Berfungsi membangkitkan kode program target dalam bahasa target yang ekivalen dengan
bahasa sumber.

• Code optimation
Berfungsi mengefisienkan kode antara yang dibentuk.
• Symbol table management
Berfungsi mengelola tabel simbol selama proses kompilasi. Tabel simbol adalah struktur data
yang memuat record untuk tiap identifier dengan atribut-atribut identifier itu.
• Penangan Kesalahan (Error handler)
Berfungsi menangani kesalahan yang berlangsung selama proses kompilasi.

9
 BAB 2 PERANCANGAN ANALISIS LEKSIKAL

I. BAHASA PEMROGRAMAN YANG DIGUNAKAN

Pada projek ini saya menggunakan bahasa pemrograman C. Bahasa C (dibuat oleh
Brian W. Kernighan dan Dennis M. Ritchie) merupakan bahasa Intermediate yang artinya
adalah bahasa tersebut bisa dikatakan sebagai High Level Language, di mana para programmer
diberikan sederetan sintaks (aturan penulisan) yang dapat dimengerti oleh manusia. Akan tetapi
bahasa C juga dapat digolongkan sebagai Low Level Language karena pada bahasa C
disediakan pula sintak dalam bentuk bahasa Assembly (di mana kita ketahui bahwa bahasa
Assembly merupakan salah satu Low Level Language).
Adapun software yang saya gunakan dalam menyelesaikan projek ini, yaitu software
Dev-C++. Salah satu software yang bisa digunakan untuk membangun sebuah program C dan
C++ yaitu Dev-C++. Salah satu kelebihan dari software ini adalah keterbukaan sumber (open
source) sehingga orang umum bisa meng-upgrade aplikasi ini serta software ini bersifat
freeware (gratis). Sehingga tidak aneh apabila software ini sangat digemari dibandingkan
software-software lain yang berbayar (biasanya lumayan mahal). Selain itu software ini juga
memungkinkan untuk menambahkan library-library yang bukan bawaan dari software ini.
Akan tetapi software ini juga memiliki kelemahan yaitu ada beberapa prosedur dan fungsi yang
ada pada software lain dihilangkan dalam Dev-C++ ini.

II. BAHASA SUMBER UNTUK DIANALISA (PASCAL)

Pada projek ini saya menggunakan bahasa sumber untuk dianalisa yaitu bahasa
pemrograman Pascal. Pascal adalah salah satu bahasa pemrograman komputer yang umumnya
digunakan sebagai pengantar untuk mulai belajar algoritma dan pemrograman. Pascal relatif
mudah dipelajari karena perintah-perintahnya yang mirip dengan bahasa inggris sehari-hari
seperti begin, end, write, dan read.
Pascal adalah bahasa pemrograman yang pertama kali di buat oleh Profesor Niklaus
Wirth, seorang anggota International Federation of Information Processing (IFIP) pada tahun
1971. Dengan mengambil nama dari matematikawan Perancis, Blaise Pascal, yang pertama
kali menciptakan mesin penghitung. Profesor Niklaus Wirth membuat bahasa Pascal ini

10
 sebagai alat bantu untuk mengajarkan konsep pemrograman komputer kepada mahasiswanya.
Selain itu, Profesor Niklaus Wirth membuat Pascal juga untuk melengkapi
kekurangankekurangan bahasa pemrograman yang ada pada saat itu.
Dari awal dikembangkan, Pascal dirancang untuk keperluan akademik. Atas alasan itu
pula Pascal masih digunakan di berbagai sekolah dan universitas di seluruh dunia (termasuk
Indonesia).

III. PENENTUAN NAMA TOKEN YANG DIPILIH

Keyword Program, Begin, End, If, Then, Else, Do, For, To, While,
Repeat, Until, Procedure, Function, Integer, Boolean, Real,
Byte, Char, Text, String, Array, Var, Record, Goto, Label,
Write, Writeln, Read, Readln, Uses, Crt, Wincrt, Set, Type,
Case, Const, Downto, External, File, Forward, Inline,
Interrupt, Nil, Of, Packed, With, Input, Output.

Operator -, +, /, *
Identifier Variable
String Ditandai dengan ‘string’
Assignment :=
Delimineter ., ,, ;, (, ), (titik, koma, titik-koma, buka kurung, tutup
kurung)
Array start, Array end [, ](kurung siku)
Range .. (dua titik)
Number 0 sampai 9
Illegal character Contoh: {, }
Relational operator <, <=, <>, =, >, >=. IN
Compiler directive $
Unary operator @
Converter # (ASCII converter)
IV. ALGORITMA/FLOWCHART UNTUK HAPUS WHITE SPACE DAN HAPUS

11
KOMENTAR

I. HAPUS WHITE SPACE

12
 II. HAPUS KOMENTAR

V. ALGORITMA/FLOWCHART TAHAPAN PENGERJAAN RE (REGULAR

EXPRESSION) DAN FSA (FINITE STATE AUTOMATA)

A. RE (REGULAR EXPRESSION)

13
• Sebuah bahasa dinyatakan regular jika terdapat finite state automata yang dapat
menerimanya.
• Bahasa-bahasa yang diterima oleh FSA bisa dinyatakan secara sederhana dengan
ekspresi regular (regular expression).
• Ekspresi regular memberikan suatu pola (pattern) atau template untuk
untai/string dari suatu bahasa.
• Banyak masalah pada perangkat lunak yang bisa disederhanakan dengan
melakukan pengubahan notasi ekspresi regular ke dalam implementasi komputer
dari FSA yang bersangkutan.
Contoh : Finite State Automata untuk mengenal bilangan bulat /integer tidak
bertanda

Ekspresi Regularnya adalah : misal 0..9 disimbolkan sebagai digit, maka, ERnya
adalah : (digit)(digit).

Notasi yang digunakan untuk ER adalah :

* : berarti bisa tidak muncul, bisa juga muncul berhingga kali (0-n)
Superscript + : berarti minimal muncul satu kali (1 -n)
+ : berarti union atau bisa diganti dengan notasi U
. : berarti konkatenasi, biasanya tanpa ditulis titiknya, misal ab sama
dengan a.b

Regular expression atau yang sering disebut sebagai Regex adalah sebuah
formula untuk pencarian pola suatu kalimat/string (Regular,2009). Sering kali orang
beranggapan bahwa regex susah dan membingungkan. Namun sebenarnya regex

14
sangatlah membantu dalam menemukan pola-pola kalimat. Sehingga percobaan
terhadap semua kemungkinan pola kalimat tidak perlu dilakukan.
Regular expression umumnya digunakan oleh banyak pengolah kata/text editor
dan peralatan lainnya untuk mencari dan memanipulasi kalimat dengan berdasarkan
kepada suatu pola tertentu. Banyak bahasa pemrograman yang mendukung regular
expression seperti misalnya PHP, perl, VB dan Tcl. Sebuah alasan yang sangat bagus
untuk menggunakan regex adalah karena regex sangatlah powerfull. Pada level rendah
regex dapat mencari sebuah penggalan kata. Pada level tinggi regex mampu
melakukan kontrol terhadap data. Baik mencari, menghapus dan merubah.

Pola Penjelasan
[] ekspresi kurung. cocok dengan satu karakter yang berada dalam kurung,
misal: pattern "a[bcd]i" cocok dengan string "abi", "aci", dan "adi".
penggunaan range huruf dalam kurung diperbolehkan, misal : pattern
"[a-z]M cocok dengan salah satu karakter diantara string "a" sampai "z".
pattern [0-9] cocok dengan salah satu angka. jika ingin mencari karakter
juga, karakter tersebut harus diletakkan di depan atau di belakang
kelompok, misal: "[abc-]".

[^ ] cocok dengan sebuah karakter yang tidak ada dalam kurung, berlawanan
dengan yang diatas. misal: pattern "[^abc]" cocok dengan satu karakter
apa saja kecuali "a", "b", "c".

? cocok dengan nol atau satu karakter sebelumnya. misal: pattern "died?"
cocok dengan string "die" dan "died".

+ cocok dengan satu atau lebih karakter sebelumnya. misal: "yu+k" cocok
dengan "yuk", "yuuk", "yuuuk", dan seterusnya.

* cocok dengan nol atau lebih karakter sebelumnya. misal: pattern "hu*p"
cocok dengan string "hp", "hup", "huup" dan seterusnya.

15
 {x} cocok dengan karakter sebelumnya sejumlah x karakter. misal: pattern
"[0- 9] {3}" cocok dengan bilangan berapa saja yang berukuran 3 digit.

{x,y} cocok dengan karakter sebelumnya sejumlah x hingga y karakter. misal:

pattern "[a-z]{3,5}" cocok dengan semua susunan huruf kecil yang
terdiri dari 3sampai 5 huruf.

! jika diletakkan di depan pattern, maka berarti "bukan". misal pattern

"!a.u" cocok dengan string apa saja kecuali string "alu", "anu", "abu",
"asu", "aiu", dan seterusnya

^ jika diletakkan di depan pattern, akan cocok dengan awal sebuah string.

$ jika diletakkan di belakang pattern, akan cocok dengan akhir sebuah

string
() Gruping digunakan untuk mengelompokkan karakter-karakter menjadi
single unit, string yang cocok dalan pattern yang berada dalam tanda
kurung dapat digunakan pada operasi berikutnya. semacam variable.

\ escape character, mengembalikan fungsi metacharacter menjadi karakter

biasa. Pada beberapa system dapat berarti sebaliknya, yaitu
metacharacter menggunakan escape character didepannya.

Contoh : L = { a, b }
1. a|b ekspresi regular untuk { a, b }
2. (a|b)(a|b) → { aa, ab, ba, bb }
3. a* ekspresi regular untuk { e, a, aa, aaa, ... }
4. (a|b)* ekspresi regular untuk himpunan semua string yang memuat nol atau
lebih a atau b.
5. a|a+b ekspresi regular untuk himpunan yang memuat a dan semua string
memuat nol atau lebih diikuti oleh b.

Jadi. identifier Pascal didefinisikan oleh:

letter { letter | digit )*

16
 Jika r dan s menyatakan bahasa yang sama, dikatakan r dan s ekivalen dan
ditulis r = s.
Contoh : (a|b) = (b|a)

Contoh RE lain:

• ER : ab*cc -> acc, abcc, abbcc, abbbcc, ab..bcc

• ER : 010* -> 01, 010, 0100, 01000, 01000..0
• ER : a*d -> d, ad, aad, aaad, aa..aad.
• ER : a+d -> ad, aad, aaad, aaaad, a..ad.
• ER : a* u b* -> a, b, aa, bb, aaa, bbb,...
• ER : (a u b) -> a, b
• ER : (a u b)* -> a,b, ab, ba, abb, baa, aaa,bbb,..
• ER : 01*+0 ->0,01,011,0111..

Berdasarkan program yang telah dibuat, maka beberapa RE dari token yang
ditentukan adalah sebagai berikut:

Delimeter Comment
[\^$.|?(),;:] RE //.... : //(.*?)
White Space RE {...} : \{(.*?)\}
[ \t\r\n\f] RE (*...*) : \(\*(.*?)\*\)
Relational Operator String
([<>=]|[<>]=|like) [a-zA-Z0-9_]
number dan operator Number
([-+]?[0-9]*\.?[0-9]+[\/\+\-\*])+([-+]?[0-9]*\.?[0-9]+) [0-9]

B. FSA (FINITE STATE AUTOMATA)

Finite state automata adalah mesin abstrak berupa sistem model matematika
dengan masukan dan keluaran diskrit yang dapat mengenali bahasa paling
sederhana (bahasa reguler) dan dapat diimplementasikan secara nyata.

17
 Finite State Automata (FSA) adalah model matematika yang dapat
menerima input dan mengeluarkan output yang memiliki state yang berhingga
banyaknya dan dapat berpindah dari satu state ke state lainnya berdasarkan input
dan fungsi transisi. Finite state automata tidak memiliki tempat
penyimpanan/memory, hanya bisa mengingat state terkini.

Finite State Automata dinyatakan oleh pasangan 5 tuple, yaitu:

M=(Q , Σ , δ , S , F )
Q = himpunan state
Σ = himpunan simbol input δ =
fungsi transisi δ : Q × Σ S = state
awal / initial state , S Q
F = state akhir, F Q

Karakteristik Finite Automata

1. Setiap Finite Automata memiliki keadaan dan transisi yang terbatas.
2. Transisi dari satu keadaan ke keadaan lainnya dapat bersifat deterministik
atau non-deterministik.
3. Setiap Finite Automata selalu memiliki keadaan awal.
4. Finite Automata dapat memiliki lebih dari satu keadaan akhir. Jika setelah
pemrosesan seluruh string, keadaan akhir dicapai, artinya otomata
menerima string tersebut.

Setiap FSA memiliki:

1. Himpunan berhingga (finite) status (state)
•Satu buah status sebagai status awal (initial state), biasa dinyatakan q0.
•Beberapa buah status sebagai status akhir (final state).
2. Himpunan berhingga simbol masukan.
3. Fungsi transisi Menentukan status berikutnya dari setiap pasang status dan
sebuah simbol masukan.

Cara Kerja Finite State Automata

18
 Finite State Automata bekerja dengan cara mesin membaca memori
masukan berupa tape yaitu 1 karakter tiap saat (dari kiri ke kanan) menggunakan
head baca yang dikendalikan oleh kotak kendali state berhingga dimana pada mesin
terdapat sejumlah state berhingga.
Finite Automata selalu dalam kondisi yang disebut state awal (initial state)
pada saat Finite Automata mulai membaca tape. Perubahan state terjadi pada mesin
ketika sebuah karakter berikutnya dibaca. Ketika head telah sampai pada akhir tape
dan kondisi yang ditemui adalah state akhir, maka string yang terdapat pada tape
dikatakan diterima Finite Automata (String-string merupakan milik bahasa bila
diterima Finite Automata bahasa tersebut).

Finite State Diagram (FSD)

Finite State Automata dapat dimodelkan dengan Finite State Diagram (FSD)
dapat juga disebut State Transition Diagram. Sistem transisi adalah sistem yang
tingkah lakunya disajikan dalam bentuk keadaan-keadaan (states). Sistem tersebut
dapat bergerak dari state yang satu ke state lainnya sesuai dengan input yang
diberikan padanya.
Fungsi Transisi (d) adalah representasi matematis atas transisi keadaan.
S = himpunan alfabet. Q =
himpunan keadaan-keadaan.
d=QxSàQ

Finite State Diagram terdiri dari:

1. Lingkaran menyatakan state
Lingkaran diberi label sesuai dengan nama state tersebut. Adapun
pembagian lingkaran adalah:

•Lingkaran bergaris tunggal berarti state sementara

•Lingkaran bergaris ganda berarti state akhir
2. Anak Panah menyatakan transisi yang terjadi.

19
 Label di anak panah menyatakan simbol yang membuat transisi dari 1 state
ke state lain. 1 anak panah diberi label start untuk menyatakan awal mula
transisi dilakukan.

Contoh FSA : mengcek parity ganjil

Misal input : 1101

Genap 1 Ganjil 1 Genap 0 Genap 1 Ganjil : diterima mesin
Misal input : 1100
Genap 1 Ganjil 1 Genap 0 Genap 0 Genap : ditolak mesin

Dari contoh diatas, maka:

Q = {Genap, Ganjil}
Σ = {0,1}
S = Genap
F = {Ganjil }

atau δ(Genap,0) =
Genap δ(Genap,1) =
Ganjil δ(Ganjil,0) =
Ganjil δ(Ganjil,1) =
Genap

20
Sebuah FSA dibentuk dari lingkaran yang menyatakan state:
• Label pada lingkaran adalah nama state
• Busur menyatakan transisi/ perpindahan
• Label pada busur yaitu symbol input
• Lingkaran yang didahului sebuah busur tanpa label menyatakan state awal
• Lingkaranb ganda menyatakan state akhir/ final. Jadi sebuah mesin
otomata dapat dinyatakan dalam diagram transisi, fungsi transisi dan tabel
transisi.

Jenis FSA
Ada dua jenis FSA :
1. Deterministic Finite Automata (DFA)
Dari suatu state ada tepat satu state berikutnya untuk setiap simbol masukan
yang diterima. Deterministik artinya tertentu/sudah tertentu fungsi transisinya.
Notasi matematis DFA:
• M = nama DFA
• Q = himpunan keadaan DFA
• S = himpunan alfabet
• d = fungsi transisi
• q0 = keadaan awal
• F = keadaan akhir
M = (Q, S, d, q0, F)

Contoh : Pengujian untuk menerima bit string dengan banyaknya 0 genap,

serta banyaknya 1 genap.
0011 : diterima
10010 : ditolak, karena banyaknya 0 ganjil
Diagram transisi-nya :

21
 DFA nya:
Q = {q0 , q1 , q2 , q3 }
Σ = {0,1} S = q0 F =
{ q0} fungsi transisi
adalah:

δ( q0,011)= δ( q2,11) =δ( q3,1)= q2 ⎝ Ditolak δ( q0,1010)=

δ( q1,010) =δ( q3,10)=δ( q2,0)= q0 ⎝Diterima
2. Non-deterministic Finite Automata (NFA)
Dari suatu state ada 0, 1 atau lebih state berikutnya untuk setiap symbol
masukan yang diterima. Non-Deterministic Finite Automata:
• Otomata berhingga yang tidak pasti untuk setiap pasangan state input,
bisa memiliki 0 (nol) atau lebih pilihan untuk state berikutnya.
• Untuk setiap state tidak selalu tepat ada satu state berikutnya untuk
setiap simbol input yang ada.
• Dari suatu state bisa terdapat 0,1 atau lebih busur keluar (transisi)
berlabel simbol input yang sama.
• Untuk NFA harus dicoba semua kemungkinan yang ada sampai
terdapat satu yang mencapai state akhir.

• Suatu string x dinyatakan diterima oleh bahasa NFA, M= (Q, _, d, S,

F) bila {x | d (S,x) memuat sebuah state di dalam F}

22
Kedua finite automata di atas mampu mengenali himpunan reguler secara presisi.
Dengan demikian kedua finite automata itu dapat mengenali string-string yang
ditunjukkan dengan ekspresi reguler secara tepat.

DFA dapat menuntun recognizer(pengenal) lebih cepat dibanding NDFA. Namun

demikian, DFA berukuran lebih besar dibanding NDFA yang ekivalen dengannya.
Lebih mudah membangun NDFA dibanding DFA untuk suatu bahasa, namun lebih
mudah mengimplementasikan DFA dibanding NDFA.

23
 BAB 3 SCREEN SHOT OUTPUT PROGRAM

• Saat program pertama kali di run. Akan tampil seperti gambar dibawah ini:

• Lalu input nama file (.pas) yang ingin di analisa. File (.pas) harap letak dalam satu folder
yang sama.

• Setelah kita input, akan muncul tampilan berupa keterangan dan source code dari file
(.pas) yang kita input-kan tadi.

24
• Hasil analisa token dan penghapusan white space akan tampil dalam file (.txt) dengan
nama file File_Token.txt dan whitespace.txt yang otomatis langsung masuk ke dalam
folder.

• Tampilan isi File_Token.txt:

25
• Tampilan isi file whitespace.txt:

26
 BAB 4 KESIMPULAN

Scanner (Analisis Leksikal), adalah sebuah komponen yang berfungsi untuk

mengkonversi atau menerjemahkan kumpulan karakter menjadi besaran token yang dapat
dimengerti kompilator.
Dalam program ini, bahasa pemrograman Pascal akan dianalisa/ scanning agar dapat dik.
Secara garis besar, token yang dihasilkan scanner dapat dibagi menjadi beberapa bagian:
a. Keyword: sekumpulan token yang sudah disediakan oleh kompilator.
b. Identifier: token yang berfungsi menjadi tanda pengenal (variable) di dalam
program.
c. Operator: sekumpulan token yang digunakan dalam proses membentuk sebuah
ekspresi (aritmatika, konkatenasi, operasi logika).
3. Delimiter: token pemisah antara token satu dan token yang lain.
4. White space character: karakter spasi yang memisahkan token satu dan yang lain.
5. Konstanta: berfungsi sebagai nilai dari variable.

Pada dasarnya, kompilator dibuat untuk memudahkan manusia/pengguna dalam

melakukan pembacaan suatu program yang ditulis dalam bahasa sumber (source code) dan
menerjemahkannya ke dalam suatu bahasa lain yang disebut bahasa sasaran (object code). Dalam
melakukan proses tersebut, kompilator akan melaporkan adanya kesalahan -kesalahan yang
mungkin ditemukan.

BAB 5 SOURCE PROGRAM

• Source program yang digunakan untuk menganalisa (nama file: compiler.c/

compiler.cpp)

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <conio.h>

27
typedef struct tokentag{
char nm[20];
} token; //array dari 0 token tipe[] = {"keyword","identifier",
"operator","relational operator", "number", "string", "illegal
character","assignment","array","delimineter", "range","compiler
directive", "converter", "Unary operator"};

// reserved words/keyword pada Pascal.

token keyword[] =
{"PROGRAM","BEGIN","END","IF","THEN","ELSE","DO","FOR","TO","WHILE","
REPEAT",
"UNTIL","PROCEDURE","FUNCTION","INTEGER","BOOLEAN","REAL","BYTE",
"CHAR","TEXT","STRING","ARRAY","VAR",
"RECORD","GOTO","LABEL","WRITE", "WRITELN", "READ", "READLN",
"USES","CRT", "WINCRT","SET",
"TYPE","CASE","CONST","DOWNTO","EXTERNAL","FILE","FORWARD","INLIN
E","INTERRUPT","NIL","OF","PACKED",
"WITH","INPUT","OUTPUT"};

long jlhKW = 50; //jumlah array keyword

char oprtr[] = { '.', ',', ';', '=', ':', '[', ']', '(', ')', '-', '+', '/',
'*',
'>', '<','$', '#', '@'};

long jlhOp = 27; //jumlah aray oprtr

typedef struct ttyptg //tabel

{ long no;
long lline;
char ctkn[50];
int typ;

28
} ttyp;

int isReserved(char tmp[]){

long i=0; char *str; str =
strupr( strdup( tmp ) );

while ( (i < jlhKW) && ( strcmp(str, keyword[i].nm) != 0) ){

i++;
}

if ( strcmp(str, keyword[i].nm) != 0) // not equal, not a keyword

return 1; return 0;
}

main(){
long i, j, ind, zz, N, NN, ln; char ch, nxt,
instr[1024], tmp[100], FName[256]; ttyp
Token[1024]; FILE *f ,*f4; char c;
printf("Masukkan Nama File Source code: ");
scanf("%s", FName); f = fopen(FName,"r");
ln = 0;
NN = 0;

while (!feof(f)){
N = 0; ch =
0;

while ( ('\n' != (ch = getc(f))) && (!feof(f)) ) // end of line check

{
instr[N] = ch;
N++;
}

29
 instr[N] = 0;
N++;

// TOKEN construction starts here

ind = 0;

while (ind < (N-1)) //

{ ch = instr[ind];
while (ch == 32) // space check
{ ind++; ch
= instr[ind];
}

if ( ind < N ) // if whole line has spaces, wil not be gone in.
{
// first 'operator' control will be done.
j = 0; while( (j < jlhOp) && (ch !=
oprtr[j]) ) j++;

if ( ch == oprtr[j] ) // so ch is an operant.
{ zz
= 0; tmp[0] = ch;
if ( ind < N ) nxt =
instr[ind + 1];

if ((nxt == '>') || (nxt == '=')) // can be one of "<>, <=, >=" .

{
zz++; tmp[1]
= nxt; ind
+=2; if ( nxt
== '>' )

30
 Token[NN].typ = 3; // relational operator
}
else if ( (ch == '.')
&& (nxt == '.'))
{
zz++;
tmp[1] = nxt;
ind +=2;
Token[NN].typ = 10; // range
}
else
ind++;
switch (ch)
{
case ':': if (nxt == '=')
Token[NN].typ = 7; else
Token[NN].typ = 9; //deli
break;
case '+':
case '-':
case '*':
case '/':

Token[NN].typ = 2;
break; // operator

case '.':
Token[NN].typ = 9;
break;

case ';':

31
 Token[NN].typ = 9;
break; // deli
case ',':
Token[NN].typ = 9;
break;
case '=':
case '>':
case '<':

Token[NN].typ = 3;
break; // relational oparator

case '[':
Token[NN].typ = 8;
break; // array start

case ']':
Token[NN].typ = 8;
break; // array end

case '(':
case ')':
Token[NN].typ = 9;
break;

case '$':
Token[NN].typ = 11;
break; // compiler directive

case '#':
Token[NN].typ = 12;
break; // ASCII converter

32
case '@':
Token[NN].typ = 13;
break; // unary operator
}
zz++;
tmp[zz] = 0; Token[NN].no =
NN; strcpy(Token[NN].ctkn,
tmp);
Token[NN].lline = ln;
NN++;
}

else if (ch == 39) // 39 = " ' " : String start

{
zz = 0; ind++;
nxt = instr[ind];
tmp[0] = nxt;

while ( nxt != 39) // end of string

{
zz++; ind++;

tmp[zz] = nxt = instr[ind];

}

tmp[zz] = 0;
Token[NN].no = NN;
strcpy(Token[NN].ctkn, tmp);
Token[NN].typ = 5;
Token[NN].lline = ln;
NN++; ind++;

33
 }

else if ( ((ch >= 65) && (ch <= 90)) || ((ch >= 97) &&
(ch <= 122)) || (ch == 95) )
// if ch is A..Z or a..z or '_' it is identifier or reserved word
{ zz
= 0; tmp[0] = ch;
nxt = instr[ind + 1];
zz++;

while ( ((nxt >= 65) && (nxt <= 90)) || ((nxt >= 97) &&
(nxt <= 122)) || (nxt == 95) || ((nxt >= 48) && (nxt <= 57)) )
// A..Z arasy, a..z arasy, '_', 0..9 arasy
{
ind++; ch =
instr[ind]; tmp[zz]
= ch; zz++;
nxt = instr[ind + 1]; }

tmp[zz] = 0;
if ( isReserved(tmp) == 0)
Token[NN].typ = 0; // keyword = reserved

else
Token[NN].typ = 1; // identifier
Token[NN].no = NN; strcpy(Token[NN].ctkn,
tmp);
Token[NN].lline = ln;
NN++; ind++;

34
 else if ( (ch >= 48) && (ch <= 57) ) // 0..9 : 'number'
{ zz
= 0; tmp[0] = ch;
nxt = instr[ind + 1];
zz++;

while ( ((nxt >= 48) && (nxt <= 57)) ) // take all 0..9 numbers.
{
ind++; ch =
instr[ind]; tmp[zz]
= ch; zz++;
nxt = instr[ind + 1];
}

tmp[zz] = 0;
Token[NN].typ = 4; // number
Token[NN].no = NN;
strcpy(Token[NN].ctkn, tmp);
Token[NN].lline = ln;
NN++; ind++;
}
else // illegal charater
{
Token[NN].no = NN;
Token[NN].ctkn[0] = ch;
Token[NN].ctkn[1] = 0;
Token[NN].typ = 6;
Token[NN].lline = ln;
NN++; ind++;
}
}//if

35
 } // while ln++; // increase
line number by one
} // while

//Kondisi perulangan untuk menghapus spasi

f = fopen(FName,"r");
f4=fopen("whitespace.txt","w");
while((c=getc(f))!=EOF)
{
if(c==' '||c=='/t')continue;
putc(c,f4);
}
fclose(f);
fclose(f4);
f4=fopen("whitespace","r");
/*
//Buat hapus komentar tapi masih looping
(ERROR) f1=fopen("input","r");
f4=fopen("comment","w");
int z=0;
while((c=getc(f1))!=EOF)
{ temp[z]=c;
z++; } for(int a=0;
a<=strlen(temp); a++){
kar=temp[a];
next=temp[a+1];
in=temp[a+2];
if(kar==47&&next==42){
while(kar!=42&&next!=47)
{
putc(in,f4);

36
 }
}
} cout<<"temp :
"<<temp[9]<<endl; fclose(f1);
fclose(f4);
*/
//tampil
fclose(f); printf("\n"); printf("---------------------------------------------------
-------------"); printf("\n"); printf("Untuk Token silahkan buka
File_Token.txt"); printf("\n"); printf("-----------------------------------------------
-----------------"); printf("\n"); printf("Untuk Hasil Penghapusan Whitespace
silahkan buka whitespace.txt"); printf("\n"); f = fopen(FName,"r");
printf("----------------------------------------------------------------");
printf("\n");
printf("Souce Program
Inputan:"); printf("\n");
printf("\n"); while((c=getc(f))!=EOF)
{
printf("%c",c);
}
fclose(f);
printf("\n");
system("pause");

//filetoken f = fopen("File_Token.txt", "w"); fprintf(f, "---

-----------------------------------------------------------\n"); fprintf(f, "|
NO | LINE | TOKEN | TIP |\n"); fprintf(f, "--
------------------------------------------------------------\n");

for(i=0;i<NN;i++)
{
fprintf(f, "| %4ld |%4ld |%10s |%20s |\n",

37
 Token[i].no, Token[i].lline, Token[i].ctkn, tipe[Token[i].typ].nm);
fprintf(f, "--------------------------------------------------------------\n"); }

fclose(f);
}

• Source program sumber yang ingin dianalisa (nama file: bintang.pas)

program bintang_dalam_bintang;
uses crt; var a, i,j:integer; begin
write('masukan bilangan: ');
readln(a); for i:=1 to (a+(a-1))
do begin for j:=1 to
(a+(a-1)) do

if (i=a) or (j=a) then write ('*')

else if i=j then write ('*') else if
j=((a+a)-i) then write ('*') else
write (' ');

writeln;
end;
readln;
end.
DAFTAR PUSTAKA

https://pakhartono.files.wordpress.com/2010/04/analisis-leksikal.pdf
http://ichaaa3.blogspot.co.id/2013/01/analisis-leksikal.html
http://semutuyet.blogspot.co.id/2012/11/makalah-tehnik-kompilasi.html
http://anotherlocalhero.blogspot.co.id/2013/12/program-scanner-untuk-melakukan.html
https://s3.amazonaws.com/ed.edim.co/18494218/bab_i_pendahuluan_c_dan_c.pdf?responseconte
ntdisposition=filename%3D%22bab_i_pendahuluan_c_dan_c.pdf%22%3B%20filename%

38
2A%3DUTF8%27%27bab_i_pendahuluan_c_dan_c.pdf&AWSAccessKeyId=AKIAJXGLFWC
DC7HTECXQ&Expires=1459147868&Signature=lGW%2F970xlCdDk6H8Zu6ivi7YHF8%3D
https://id.wikipedia.org/wiki/Pascal_(bahasa_pemrograman) http://www.duniailkom.com/tutorial-
belajar-pascal-jenis-jenis-operator-dalam-bahasapemrograman-pascal/
https://kangrandypranarelza.wordpress.com/2012/01/11/lexical-analysis-in-compiler-design/
http://pelita-informatika.com/berkas/jurnal/1.%20jurnal%20Sinar%20sinurat.pdf
http://ojs.unud.ac.id/index.php/jik/article/viewFile/2677/1891
http://documents.tips/documents/makalahtekomnimas.html http://ruby-doc.org/core-
2.1.1/Regexp.html http://stackoverflow.com/questions/14660878/regular-expression-for-
comments-in-pascal http://www.allinterview.com/showanswers/73305/write-program-remove-c-
comments-and-fromfile-should-be-declared-command-line.html
http://dhiaheka.blogspot.co.id/2013/05/regular-expressionregex-pada-c_2196.html
https://riskasimaremare.wordpress.com/2013/04/23/finite-state-automata/

39