RANCANG BANGUN MESIN COMPILER

UNTUK BAHASA PEMROGRAMAN BOLT-11

BERBASIS PYTHON
LAPORAN

Disusun untuk memenuhi tugas proyek akhir Mata Kuliah Teknik Kompilasi
Dosen Pengampu : Aji Purwinarko, S. Si., M. Cs.

Disusun oleh: Kelompok 11

Hanief Widya Wardhana (4611420024)

Muhammad Afifudin (4611420025)

Uswanto (4611421142)

PROGRAM STUDI TEKNIK INFORMATIKA

JURUSAN ILMU KOMPUTER

FAKULTAS MATEMATIKA DAN ILMU PENGETAHUAN ALAM

UNIVERSITAS NEGERI SEMARANG

2022
 DAFTAR ISI

DAFTAR ISI ................................................................................................................................. 1

BAB 1 ........................................................................................................................................... 2
PENDAHULUAN ........................................................................................................................ 2
BAB 2 ........................................................................................................................................... 4
KAJIAN PUSTAKA ..................................................................................................................... 4
BAB 3 ......................................................................................................................................... 12
HASIL DAN PEMBAHASAN ................................................................................................... 12
BAB 4 ......................................................................................................................................... 14
DAFTAR PUSTAKA ................................................................................................................. 15

1
 BAB 1
PENDAHULUAN

1.1. Latar Belakang

Bahasa pemrograman merupakan hal yang paling sering dipelajari,
terutama oleh mahasiswa yang masuk program studi teknik informatika. Di
dalamnya dikenal banyak istilah seperti syntax, iterasi, percabangan, input,
prosedur, output, dan banyak istilah lain yang penting untuk dipahami. Namun,
mahasiswa bukan hanya harus mengetahui bagaimana cara mengimplementasikan
dalam pembuatan program tertentu, tetapi juga harus memahami bagaimana
tahapan-tahapan dalam pembuatannya. Bahasa pemrograman dibangun dengan
mesin compiler yang bisa menerjemahkan bahasa yang dibuat. Mesin compiler
juga dapat dibangun dengan bahasa pemrograman lain tanpa harus memulainya
dari nol.
Dalam pembuatan mesin compiler ada beberapa kriteria yang harus
dipenuhi. Menurut Aditya, parser dan lexer merupakan suatu kewajiban ketika
membangun sebuah compiler (Aditya, 2019). Lexer merupakan komponen yang
berfungsi untuk mendeteksi setiap token dari suatu bahasa, sedangkan parser
merupakan komponen untuk mendeteksi struktur dari beberapa token. Selain itu,
mesin compiler juga harus dapat mendeteksi suatu kesalahan dalam syntax yang
dibuat oleh pengguna. Kombinasi antara algoritma dan masukan dari pengguna
menghasilkan keluaran yang tepat merupakan indikator keberhasilan pembuatan
suatu mesin compiler.
Pembuatan mesin compiler menarik untuk dipelajari lebih dalam lagi.
Melalui laporan ini, penulis akan memberikan laporan hasil percobaan
membangun sebuah mesin compiler berbasis bahasa pemrograman python untuk
menerjemahkan bahasa pemrograman yang dibuat secara mandiri yang disebut
BOLT-11. Diharapkan melalui tugas proyek ini bisa menambah pengetahuan dan
pengalaman mahasiswa dalam menyerap konsep materi-materi pada Mata Kuliah
Teknik Kompilasi.

1.2. Rumusan Masalah

Melalui laporan ini, beberapa rumusan masalah akan diselesaikan sebagai
berikut.
1. Apa hubungan antara bahasa pemrograman dengan mesin compiler ?
2. Tahapan-tahapan apa saja dalam pembuatan mesin compiler ?
3. Bagaimana implementasi mesin compiler berbasis bahasa pemrograman
python ?
4. Apa saja yang bisa diselesaikan oleh mesin compiler bila diujikan pada
bahasa pemrograman BOLT-11 ?

2
1.3. Tujuan
Melalui laporan ini, beberapa tujuan yang ingin dicapai oleh penulis adalah
sebagai berikut.
1. Mengetahui hubungan antara bahasa pemrograman dengan mesin
compiler.
2. Mengidentifikasi tahapan-tahapan dalam pembuatan mesin compiler.
3. Mempelajari implementasi mesin compiler dengan bahasa pemrograman
python.
4. Mengimplementasikan mesin compiler dengan bahasa pemrograman
BOLT-11.

1.4. Manfaat
Setelah penyusunan laporan ini, beberapa manfaat yang akan didapatkan penulis
maupun pembaca adalah sebagai berikut.
1. Mengetahui lebih dalam mengenai bahasa pemrograman dan mesin
compiler.
2. Memahami kriteria dan tahapan dalam pembuatan mesin compiler.
3. Mengimplementasikan algoritma mesin compiler dengan bahasa
pemrograman python.
4. Memudahkan dalam mempelajari konsep-konsep dalam materi di Mata
Kuliah Teknik Kompilasi.

3
 BAB 2
KAJIAN PUSTAKA

2.1. Bahasa Pemrograman dan Mesin Compiler

Menurut Yulikuspartono (2009:29), “program merupakan sederetan instruksi

atau statement dalam bahasa yang dimengerti oleh komputer yang bersangkutan”.
Sedangkan menurut Binanto (2009:1), kata program dan pemrograman dapat
diartikan sebagai berikut:

1. Program merupakan himpunan atau kumpulan instruksi tertulis yang dibuat oleh
programmer atau suatu bagian executable dari suatu software.
2. Pemrograman berarti membuat program komputer.
3. Pemrograman merupakan suatu kumpulan urutan perintah ke komputer untuk
mengerjakan sesuatu. Perintah-perintah ini membutuhkan suatu bahasa
tersendiri yang dapat dimengerti oleh komputer.
4. Mendeskripsikan instruksi-instruksi tersendiri yang biasanya disebut source
code yang dibuat oleh programmer.
5. Mendeskripsikan suatu keseluruhan bagian dari software yang executable.

Bahasa pemrograman pun terdapat 4 tingkatan, yaitu:

1. Bahasa Mesin
Merupakan bahasa yang hanya dapat dimengerti oleh mesin komputer,
yang didalamnya terdapat Central Processing Unit (CPU) yang hanya mengenal
dua keadaan yang berlawanan, yaitu bila ada arus maka bernilai 1 (true), dan jika
tidak ada arus maka bernilai 0 (false).

2. Bahasa Tingkat Rendah (Low Level Language)

Karena banyaknya keterbatasan yang dimiliki bahasa mesin, maka
dibuatlah simbol yang mudah diingat yang disebut dengan mnemonic (pembantu
untuk mengingat).
Contoh: Bahasa Assembler

3. Bahasa Tingkat Menengah (Middle Level Language)

Bahasa pemrograman yang menggunakan aturan-aturan gramatikal dalam
penulisan pernyataannya, mudah untuk dipahami, dan memiliki intruksi-intruksi
tertentu yang dapat langsung diakses oleh komputer.
Contoh : Bahasa C

4. Bahasa Tingkat Tinggi (High Level Language)

Bahasa pemrograman yang dalam penulisan pernyataannya mudah
dipahami secara langsung.
Contoh: Bahasa Fortran, Pascal, Cobol.

4
 Sedangkan compiler adalah perangkat lunak sistem yang melakukan
proses transformasi terhadap suatu program sumber menjadi program target.
Dalam hal ini, program sumber yang digunakan adalah bahasa pemrograman
tingkat tinggi, dan program targetnya berupa bahasa assembly. Sebagai
penerjemah, compiler harus mampu membimbing penggunanya apabila terdapat
kesalahan dalam program sumber.

2.2. Library SLY (Sly Lex Yacc)

SLY adalah library yang digunakan untuk menulis parser dan compiler. SLY
secara bebas didasarkan pada alat konstruksi tradisional compiler Lex dan Yacc dan
mengimplementasikan algoritma parsing LALR yang sama. Sebagian besar fitur
yang tersedia di Lex dan Yacc juga tersedia di SLY.

SLY menyediakan dua kelas terpisah yaitu Lexer dan Parser. Kelas Lexer
digunakan untuk memecah teks input menjadi kumpulan token yang ditentukan oleh
kumpulan aturan ekspresi reguler. Sedangkan kelas Parser digunakan untuk
mengenali sintaks bahasa yang telah ditentukan dalam bentuk tata bahasa bebas
konteks. Dua kelas biasanya digunakan bersama untuk membuat parser. Namun, ini
bukan persyaratan ketat (ada banyak fleksibilitas yang diperbolehkan).

2.3. Tahapan-Tahapan Pembuatan Mesin Compiler

2.2.1. Pembuatan Lexer

Lexer merupakan sebuah komponen yang berfungsi untuk mengkonversi
atau menerjemahkan kumpulan-kumpulan karakter atau source code ke dalam
urutan token leksikal (string dengan makna yang ditetapkan), sehingga kompilator
dapat membuat perintah, operator, dan yang lainnya. Dalam Bolt, penentuan
karakter ke dalam token dapat dilihat dibawah ini:

class BoltLexer(Lexer):
tokens = { NAME, NUMBER, STRING, IF, PRINT, THEN,
ELSE, FOR, FUN, TO, ARROW, EQEQ }
ignore = '\t '

literals = { '=', '+', '-', '/', '*', '(', ')',

',', ';', '<', '>' , ':'}

# Pendefinisian Token
IF = r'JIKA'
PRINT = r'CETAK'
THEN = r'MAKA'
ELSE = r'KEMUDIAN'

5
 FOR = r'UNTUK'
FUN = r'FUNGSI'
TO = r'SAMPAI'
ARROW = r'->'
NAME = r'[a-zA-Z_][a-zA-Z0-9_]*'
STRING = r'\".*?\"'
EQEQ = r'=='

2.2.2. Pembuatan Parser

Parser adalah komponen dari kompilator yang berfungsi untuk mengambil
token yang telah dikonversi pada lexer, sehingga parser dapat menciptakan sebuah
pohon sintaks dari token-token tersebut.

class BoltParser(Parser):
tokens = BoltLexer.BoltLexer.tokens

precedence = (
('left', '+', '-'),
('left', '*', '/'),
('right', 'UMINUS'),
)

def __init__(self):
self.env = { }

@_('')
def statement(self, p):
pass

@_('FOR var_assign TO expr THEN statement')

def statement(self, p):
return ('for_loop', ('for_loop_setup', p.var_assign,
p.expr), p.statement)

@_('IF condition THEN statement ELSE statement')

def statement(self, p):
return ('IF_stmt', p.condition, ('branch', p.statement0,
p.statement1))

@_('FUN NAME "(" ")" ARROW statement')

6
def statement(self, p):
return ('fun_def', p.NAME, p.statement)

@_('NAME "(" ")"')

def statement(self, p):
return ('fun_call', p.NAME)

@_('expr EQEQ expr')

def condition(self, p):
return ('condition_eqeq', p.expr0, p.expr1)

@_('var_assign')
def statement(self, p):
return p.var_assign

@_('NAME "=" expr')

def var_assign(self, p):
return('var_assign', p.NAME, p.expr)

@_('NAME "=" STRING')

def var_assign(self, p):
return('var_assign', p.NAME, p.STRING)

@_('expr')
def statement(self, p):
return(p.expr)

@_('expr "+" expr')

def expr(self, p):
return ('add', p.expr0, p.expr1)

@_('expr "-" expr')

def expr(self, p):
return ('sub', p.expr0, p.expr1)

@_('expr "/" expr')

def expr(self, p):
return ('div', p.expr0, p.expr1)

7
 @_('expr "*" expr')
def expr(self, p):
return ('mul', p.expr0, p.expr1)

@_('expr "%" expr')

def expr(self, p):
return ('mod', p.expr0, p.expr1)

@_('expr "<" expr')

def expr(self, p):
return('less', p.expr0, p.expr1)

@_('expr ">" expr')

def expr(self, p):
return('greater', p.expr0, p.expr1)

@_('"-" expr %prec UMINUS')

def expr(self, p):
return p.expr

@_('NAME')
def expr(self, p):
return('var', p.NAME)

@_('NUMBER')
def expr(self, p):
return('num', p.NUMBER)

@_('PRINT expr')
def expr(self, p):
return ('print', p.expr)

@_('PRINT STRING')
def statement(self, p):
return ('print', p.STRING)

2.2.3. Pembuatan Interpreter

Interpreter adalah perangkat lunak yang mampu mengeksekusi kode program, lalu
menerjemahkannya ke dalam bahasa mesin. Sehingga, mesin dapat melakukan instruksi

8
yang ditulis oleh programmer dengan mengeksekusi baris demi baris. Berbeda dengan
proses compiler, yang mana proses compiler akan langsung menghasilkan program
berupa satu kesatuan perintah dalam bentuk bahasa mesin, dan proses penerjemahan
dilakukan sebelum program tersebut dieksekusi.

class BoltExecute:

def __init__(self, tree, env):

self.env = env
result = self.walkTree(tree)
if result is not None and isinstance(result,
int):
print(result)
if isinstance(result, str) and result[0] ==
'"':
print(result)

def walkTree(self, node):

if isinstance(node, int):
return node
if isinstance(node, str):
return node
if node is None:
return None
if node[0] == 'program':
if node[1] == None:
self.walkTree(node[2])
else:
self.walkTree(node[1])
self.walkTree(node[2])
if node[0] == 'num':
return node[1]
if node[0] == 'str':
return node[1]
if node[0] == 'print':
if node[1][0] == '"':
print(node[1][1:len(node[1])-1])
else:
return self.walkTree(node[1])
if node[0] == 'if_stmt':

9
 result = self.walkTree(node[1])
if result:
return self.walkTree(node[2][1])
return self.walkTree(node[2][2])
if node[0] == 'condition_samadengan':
return self.walkTree(node[1]) ==
self.walkTree(node[2])
if node[0] == 'func_def':
self.env[node[1]] = node[2]
if node[0] == 'func_call':
try:
return self.walkTree(self.env[node[1]])
except LookupError:
print("Undefined function '%s'" % node[1])
return 0
if node[0] == 'add':
return self.walkTree(node[1]) +
self.walkTree(node[2])
elif node[0] == 'sub':
return self.walkTree(node[1]) -
self.walkTree(node[2])
elif node[0] == 'mul':
return self.walkTree(node[1]) *
self.walkTree(node[2])
elif node[0] == 'div':
return int(self.walkTree(node[1]) /
self.walkTree(node[2]))
if node[0] == 'var_assign':
self.env[node[1]] = self.walkTree(node[2])
return node[1]
if node[0] == 'var':
try:
return self.env[node[1]]
except LookupError:
print("Undefined variable
'"+node[1]+"' found!")
return 0
if node[0] == 'for_loop':
if node[1][0] == 'for_loop_setup':

10
 loop_setup = self.walkTree(node[1])
loop_count = self.env[loop_setup[0]]
loop_limit = loop_setup[1]

for i in range(loop_count+1,
loop_limit+1):
res = self.walkTree(node[2])
if res is not None:
print(res)
self.env[loop_setup[0]] = i
del self.env[loop_setup[0]]

if node[0] == 'for_loop_setup':
return (self.walkTree(node[1]),
self.walkTree(node[2]))

2.2.3. Pembuatan Program Utama

Program utama berfungsi untuk menjembatani file source code yang
memiliki ekstensi ‘.blt’ untuk kemudian dieksekusi oleh lexer, parser, dan
interpreter.

lexer = BoltLexer.BoltLexer()
parser = BoltParser.BoltParser()
env = {}

file = open(argv[1])
text = file.readlines()
for line in text:
tree = parser.parse(lexer.tokenize(line))
BoltExe.BoltExecute(tree, env)

11
 BAB 3
HASIL DAN PEMBAHASAN

3.1. PERINTAH PADA BAHASA PEMROGRAMAN BOLT

3.1.1. Operasi Aritmatika
Dalam bahasa pemrograman Bolt, operasi perhitungan aritmatika seperti
penjumlahan, pengurangan, perkalian, dan pembagian dapat langsung ditulis
dengan angka yang ingin dilakukan proses perhitungan. Untuk hasil operasi
pembagian hanya dapat berupa bilangan integer, dan semua hasil perhitungan
akan langsung tercetak pada console.

3.1.2. Perintah “CETAK” dan penggunaan komentar

Perintah CETAK pada bahasa pemrograman Bolt mewakili perintah
PRINT yang biasa digunakan untuk menampilkan output yang ingin kita cetak
pada console.
Sedangkan komentar yang digunakan untuk menandai atau menulis
keterangan, yang tidak akan dijalankan oleh mesin pada bahasa pemrograman
Bolt hanya dengan menambahkan tanda ‘#’ di awal kalimat.

3.1.3. Perintah “UNTUK”, “SAMPAI”, dan “MAKA”

12
 Pada Bolt, perintah UNTUK jika diikuti dengan ekspresi, perintah
SAMPAI diikuti dengan statement 1, dan perintah MAKA diikuti dengan
statement 2, maka dapat digunakan untuk melakukan looping pada program
dengan logika FOR dan TO.

3.1.4. Perintah “FUNGSI”

Pada Bolt, perintah FUNGSI dapat digunakan untuk membuat suatu
fungsi dengan menambahkan nama fungsi, dan statement di dalamnya. Saat fungsi
tersebut dipanggil, maka statement nya pun akan dijalankan oleh program.

13
 BAB 4
KESIMPULAN DAN SARAN

4.1. Kesimpulan

Mahasiswa dituntut untuk bisa bukan hanya mengimplementasikan bahasa

pemrograman, tetapi mahasiswa juga harus mengetahui kriteria dan tahapan-
tahapan dalam pembuatannya. Bahasa pemrograman yang dibangun dengan
mesin compiler membutuhkan parser dan lexer sebagai komponen utama. Selain
itu, mesin compiler juga harus dapat mendeteksi suatu kesalahan dalam syntax
yang dibuat oleh pengguna. Kombinasi antara algoritma dan masukan dari
pengguna menghasilkan keluaran yang tepat merupakan indikator keberhasilan
pembuatan suatu mesin compiler. Melalui hasil percobaan membangun sebuah
mesin compiler berbasis bahasa pemrograman python, ternyata mesin compiler
bisa untuk menerjemahkan bahasa pemrograman yang dibuat secara mandiri yang
yaitu BOLT-11. Melalui proyek ini, kami menjadi lebih paham tentang materi-
materi dalam Mata Kuliah Teknik Kompilasi, menambah pengetahuan, dan
pengalaman dalam membangun bahasa pembangun mesin compiler secara
mandiri.

4.2. Saran
Walaupun mesin compiler dapat menjalankan perintah dengan baik, tetapi
masih banyak kesalahan yang ditemui apabila mengimplementasikan algoritma
yang lebih kompleks. Melalui hal ini, penulis disarankan lebih bisa
mengembangkannya menjadi lebih sempurna, sehingga turut andil dalam
kontribusi membangun Ilmu Pengetahuan dan Teknologi (IPTEK).

14
 DAFTAR PUSTAKA

Purwa, Aditya . (2019) . Berkenalan dengan ANTLR untuk Membuat Bahasa Bot Engine
Sederhana . Diakses di https://medium.com/pujanggateknologi/berkenalan-
dengan-antlr-untuk-membuat-bahasa-bot-engine-sederhana-cf1292950f98 pada
24 Maret 2022

Apriansyah, Andez., Saputra, Tri Ichsan., Fauziah., & Wijaya, Yunan Fauzi. (2019).
Desain Mesin Compiler untuk Penganalisa Leksikal, Sintaksis, Semantik, Kode
Antara dan Error Handling Pada Bahasa Pemrograman Sederhana.

15