TUGAS 1 TEKNIK KOMPILASI

PEMBUATAN SCANNER

Oleh :

ANGGI NAMORA SITEPU (131401092)

PROGRAM STUDI S1 ILMU KOMPUTER

FAKULTAS ILMU KOMPUTER DAN TEKNOLOGI INFORMASI
UNIVERSITAS SUMATERA UTARA
MEDAN
2016
 DAFTAR ISI

Daftar Isi.................................................................................................................................i

BAB I ANALISIS LEKSIKAL

1.1 Analisis Leksikal................................................................................................1

1.2 Posisi Analisis Leksikal dalam Kompilator.......................................................2

BAB II PERANCANGAN SCANNER

2.1 Bahasa Pemrograman yang Digunakan (C#).....................................................3

2.2 Bahasa Sumber Analisa (Pascal).......................................................................3
2.3 Penentuan Nama Token.....................................................................................4
2.4 Algoritma/Flowchart Penghapusan Komentar dan Whitespace........................4
2.5 Tahapan Pengerjaan RE.....................................................................................4
2.6 Finite State Automata........................................................................................5

BAB III SCREENSHOT

3.1 Screenshot Scanner............................................................................................6

BAB IV KESIMPULAN

4.1 Kesimpulan Laporan..........................................................................................5

BAB V SOURCECODE

5.1 Sourcecode Program..........................................................................................7

 BAB I

ANALISIS LEKSIKAL

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

1.2 Posisi Analisis Leksikal dalam Kompilator

Analisis Leksikal merupakan tahap awal dalam proses kompilasi sebuah

bahasa. Mengapa analisis leksikal diperlukan ? Hal tersebut dikarenakan analisis
leksikal/scanner akan menghasilkan token-token yang akan memudahkan proses
selanjutnya yaitu parsing.

Analisis leksikal menangani kerumitan sistem masukkan/keluaran. Karena

analisis leksikal biasanya berhubungan langsung dengan kode sumber yang diwadahi
file, maka analisis leksikal juga bertindak sebagai benteng untuk komponen-
komponen lain di kompilator dalam mengatasi keanehan-keanehan sistem
masukkan/keluaran sistem operasi dan sistem komputer.

Analisis leksikal juga memiliki beberapa tugas spesifik yaitu seperti

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. Hal ini
lah yang mendasari bahwa posisi analisis leksikal dalam proses kompilasi bahasa
sangatlah penting.
 BAB II

PERANCANGAN SCANNER

2.1 Bahasa Pemrograman yang digunakan (C#)

Bahasa pemograman C-Sharp (C#) dikembangkan oleh Microsoft sebagai
bahasa yang simple, modern, general-purpose, dan berorientasi objek. Pengembangan
bahas C# sangat dipengaruhi oleh bahasa pemograman sebelumnya, terutama C++,
Delphi, dan Java. C++ Dikenal memiliki kecepatan yang tinggi dan memiliki akses
meomori hingga ke level terendah. Namun bagi programmer, bahasa C++ relative
lebih sulit dibanding bahasa pemograman lainnya. Bahasa C# sampai saat ini masih
terus dikembangkan untuk melakukan berbagai task, tetapi dalam hal performance C+
+ masih di akui sebagai salah satu yang terbaik sampai saat ini.
C# dikembangkan sejalan dengan pengembangan teknologi .Net. .Net
merupakan sebuah framework yang memiliki base class library dan bisa
diimplementasikan dalam beberapa bahasa pemograman yang dikembangkan oleh
Microsoft. Microsoft .Net framework adalah perantara perantara agar aplikasi dengan
bahasa pemograman yang didukung dapat berkomunikasi dengan system operasi yang
digunakan oleh computer. .Net framework juga memungkinakan C# untuk
berkomunikasi dengan bahasa pemograman lainnya yang didukung oleh
framework .Net seperti VB.Net, F#, atau C++.
Salah satu karakteristik .Net adalah Common Language Runtime (CLR). CLR
merupakan komponen virtual machine yang akan mengeksekusi program pada saat
runtime. Code yang di tulis dalam bahasa C# atau VB.Net akan di compile menjadi
kode dalam format Common Intermediate Language (CIL).

2.2 Bahasa Sumber Analisa (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 diambil dari nama ahli matematika prancis abad pertengahan, Blaise
Pascal. Bahasa Pascal di kembangkan oleh Niklaus Wirth pada tahun 1970, dan
populer digunakan pada era 1970 hingga awal 1990an.

2.3 Penentuan Nama-nama Token

Token – token yang diambil dibagi menjadi beberapa leksikal yaitu :
Keyword / Reserved Words:

And Export Shl Label With

Array Nil Shr Library Xor
Asm Not File Mod Else
Begin Object For String Set
Case Or Function Then Interface
Const Or Goto To While
Constructor Packed If Type Downto
Destructor Procedure Implementation Unit Repeat
Div Program In Until Inline
Do Record Inherited Uses Var

Identifier :
Semua letter yang memiliki syarat :
-> [a-z][A-Z][0-9] [a-z][A-Z]

Operator :
Semua operator yang biasa dipakai dalam Pascal
-> + , - , / , * , := , mod , div

Relational Operator(Operasi Logika) :

Semua operator logika yang biasa dipakai dalam Pascal
-> < , > , = , <= , >= , !=

Delimiter :
Semua bentuk pungtuasi dan kurung yang biasa dipakai dalam Pascal
-> ( , ) , [ , ] , , , . , : , ;

Konstanta (Integer) :
Semua bilangan yang termasuk dalam bilangan integer
 -> [0-9][0-9]…
2.4 Algoritma Penghapusan WhiteSpace dan Komentar
Whitespace
Procedure spaces
Begin
While karakter=” ” do getchar;
Repeat
Case karakter of
‘ ‘ : begin //menentukan spasi
Delete karakter; //penhapusan spasi
Repeat getchar;
End;
EOF:exit;
End;
Komentar
Procedure comment
Begin
While karakter=” “ do Getchar;
Repeat
Case karakter of
‘{‘ : begin //penentuan awal kurung komentar
repeat Getchar; //men-scan seluruh karakter dan mengabaikannya
//sampai akhir kurung komenter ditemukan
until karakter=’}’; //menentukan akhir kurung komentar
end;
EOF:exit;
End;

2.5 Tahapan Pengerjaan Regular Expression (RE)

Regular expressions adalah deskripsi yang dapat digunakan untuk
menggambarkan bahasa regular. Sebuah bahasa dinyatakan regular jika terdapat finite
state automata yang dapat menerimanya. Bahasa-bahasa yang diterima oleh suatu
FSA bisa dinyatakan secara sederhana dengan ekspresi regular. Ekspresi Regular
 (ER), memungkinkan menspesifikasikan atau mendefinisikan bahasa-bahasa. Ekspresi
Regular memberikan suatu pola dari suatu bahasa. String/untai yang menyusun suatu
bahasa regular akan cocok dengan pola bahasa itu.

Notasi Ekspresi Regular

Supescript * : 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
Identifier :
letter(letter|digit)*
-> dengan artian set yang dapat menjadi identifier ialah yang dimulai dengan letter
([a-z]|[A-Z]) lalu diikuti dengan boleh letter ([a-z]|[A-Z]) juga atau digit ([0-9]), dan
dapat diulang.
Number /Integer:
digit*
-> dengan artian bahwa semua nilai bilangan yang integer dapat diterima kecuali
bilangan real, imaginer , dsb.
Delimiter
(: | ; | . | , | [ | ] | ( | ) )*
-> dengan artian bahwa semua symbol yang dapat digunakan sebagai delimiter dalam
pascal dapat diterima dan dapat berulang
Operator :
(+ | - | * | mod | div)*
->dengan artian bahwa semua operator aritmatika dasar dapat diterima sebagai
inputan
Operator Logika :
( := | = | > | < | <= | >=)
-> dengan artian bahwa semua operator logika yang biasa digunakan dapat diterima.

2.6 Finite State Automata

Mengambil input berupa string dan menentukan apakah string tersebut merupakan
kalimat yang sah dari suatu bahasa.
– Sebuah finite automaton memiliki states yang terhingga
– Sisi membawa dari satu state ke state selanjutnya
– Sisi diberi label symbol
– Satu state merupakan start state
– Satu atau lebih state merupakan final state

Contoh :

Misalkan sebuah sebuah bahasa memiliki himpunan simbol terminal / token yaitu : < ,
> , =, <= , >=, <> . Atau bisa dibaca sebagai token-token : t_L, t_G, t_E, t_LE, t_GE,
t_NE ( G=Greater, L=Less, E=Equal, N=not)

Bahasa tersebut juga mendukung penulisan komentar yang diawali dengan “{“ dan
diakhiri “}”.

Maka diagram state untuk bahasa tersebut :

< =
Start t_L t_LE

} = >

t_NE
t_E
>
{
= =

Komentar t_G t_GE

Apa saja selain }

 BAB III
SCREENSHOT

3.1 Screenshot Scanner

 BAB IV
KESIMPULAN

4.1 Kesimpulan Laporan

Analisis Leksikal adalah tahap pertama/awal dalam proses kompilasi , mendahului

proses analisis sintaksis/parsing dan analisis semantic. Tugas utama analisis leksikal
adalah untuk memecah bahasa sumber kedalam bentuk token – token terorganisis
dimana token – token tersebut akan dilanjutkan ke dalam proses parsing.

Token – token yang telah dihasilkan dalam proses leksikal terdiri dari beberapa
seperti identifier, keyword, konstanta, operator dsb. Dan token-token ini diperoleh
dengan menggunakan Finite State Automata.

Dan dengan munculnya token-token dalam scanner maka scanner dapat dinyatakan
berjalan dengan baik.
 BAB V
SOURCE CODE

5.1 Source code Program

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Drawing;
using System.Windows.Forms;

namespace latihan1
{
    /// <summary>
    /// Description of MainForm.
    /// </summary>
    public partial class MainForm : Form
    {
        public MainForm()
        {            InitializeComponent();
            
        }
        
        void Button1Click(object sender, EventArgs e)
        {    
            
            
            string coding=tb1.Text;
            tokens.Clear();
            cektokens.Clear();
            string result="";
            bool error=false;

> Code untuk menghapus komentar dan whitespace

            string clear=tb1.Text;
            clear = clear.Replace(" ", "");
            clear = Regex.Replace(clear, @"\{(.*)\}", "");
            tb2.Text = clear;
            string temp="";
            for(int i=0;i<coding.Length;i++){
                if(char.IsWhiteSpace(coding[i])){
                    i++;
                    while (i<coding.Length){
                        if(char.IsWhiteSpace(coding[i])){
                            i++;
                        }
                        else {i--; break;}
                    }
                    if(temp != ""){
                        tokens.Add(temp);
                    }
                    temp="";
                }
                else {temp += coding[i];}
            }
            if (temp !="") tokens.Add(temp);
            
            for(int i=0;i<tokens.Count;i++){
                if(_keyword(tokens[i])){
                    cektokens.Add(tokens[i] +" \t:
keyword"+System.Environment.NewLine);
                }
                else if(_id(tokens[i])){
                    cektokens.Add(tokens[i] +" \t: id"+System.Environment.NewLine);
                }
                else if(_int(tokens[i])){
                    cektokens.Add(tokens[i] +" \t: int"+System.Environment.NewLine);
                }
                else if(_opr(tokens[i])){
                    cektokens.Add(tokens[i] +" \t: opr"+System.Environment.NewLine);
                }
                else if(_oprlogika(tokens[i])){
                    cektokens.Add(tokens[i] +" \t: logopr"+System.Environment.NewLine);
                }
                else if(_delimiter(tokens[i])){
                    cektokens.Add(tokens[i] +" \t:
delimiter"+System.Environment.NewLine);
                }
            }
            if (error){}
            else{for (int i=0;i<cektokens.Count;i++){
                    result += cektokens[i] +"";
                }
            } tb2.Text=result;
            
        }
        
        
        List<string> tokens=new List<string>();
        List<string> cektokens=new List<string>();
        string[] keyword={"and","array","asm","begin","case","const","constructor","div
","do","export","nil","not","object","of","or","packed","procedure",
                            "program","record","shl","shr","file","for","function","goto","if","i
mplementation","in","inherited","label","library","mod","string",
                            "then","to","type","write","writeln","read","wincrt","crt","readln","u
nit","until","uses","wih","xor","else","set","interface","while","begin","end","downto
","repeat","inline","var","integer","byte","longint"};
        string[] opr={"+","-","/","*",":=","mod","div"};
        string[] log={"<",">","=","<=",">=","!="};
        string[] del={".",",",":",";","(",")","[","]"};

        > Untuk menentukan keyword pada pascal dengan memanfaatkan table

symbol (dengan menggunakan array)
        bool _keyword(string lex){
            for (int i=0;i<keyword.GetLength(0);i++){
                if(lex==keyword[i]) return true;
            }
            return false;
        }
        >Untuk membaca bilangan bulat diawali digit 0-9, bisa diikuti digit 0-9
        bool _int(string lex){
            for (int i=0;i<lex.Length;i++){
                if(lex[i]>= '0' && lex[i]<='9'){
                    return true;
                }
                else {return false;}
    }
            return true;
        }
            
        
        bool _opr(string lex){
            for (int i=0;i<opr.GetLength(0);i++){
                if(lex==opr[i]) return true;
            }
            return false;
        }
        
        bool _oprlogika(string lex){
            for (int i=0;i<log.GetLength(0);i++){
                if(lex==log[i]) return true;
            }
            return false;
        }
        bool _delimiter(string lex){
            for (int i=0;i<del.GetLength(0);i++){
                if(lex==del[i]) return true;
            }
            return false;
        }
        
> Untuk menentukan identifier beserta atributnya

        bool _id(string lex){
            if(lex[0]>='a' && lex[0] <='z'){
                for(int i=0;i<lex.Length;i++){
                    if(lex[i]>='a' && lex[i] <='z'){
                        
                    }
                    else if(lex[i]>='0' && lex[i]<='9'){
                        
                    }
                    else{
                        return false;
                    }
                }
            return true;
        }
        return false;
        }
            
        }
    }