0

SCANNER DAN PARSER TEKNIK KOMPILASI

Posted by Jujur Sitanggang on 7:20 PM
MAKALAH
SCANNER DAN PARSER TEKNIK KOMPILASI


D:\Paul\KULIAH\Lambang_UNIKOM.png






Disusun oleh :
Nama
                Nim
Candra P. Simatupang
10112675
Jujur Soaloon Sitanggang
10112672
Andrianto
10112700




PROGRAM STUDI TEKNIK INFORMATIKA
FAKULTAS TEKNIK DAN ILMU KOMPUTER
UNIVERSITAS KOMPUTER INDONESIA
BANDUNG 2015




  1. PENJELASAN CARA KERJA PROGRAM
Bahasa yang digunakan adalah bahasa C#(Csharp) dimana pada bahasa pemrograman ini berbasis objek. Program membaca sebuah file bersisi source code pascal dengan ekstensi .pas .  File sumber tadi akan di simpan di dalam array lalu akan di scan menggunakan scanner untuk mengidentifikasi tiap token yang ada. Setelah setiap token telah di identifikasikan sekarang bagian parser untuk bekerja mencocokan tiap token tadi dengan grammar yang ada.
  1. PENTUNJUK PENGGUNAAN PROGRAM
Petunjuk penggunaan program yaitu:
  1. Buka folder dengan nama Kelompok03-TK-04
  2. Pilih folder yang diberi nama Program dan buka
  3. Pilih folder App jika ingin Melihat Calss dari Program Scanner dan Parser ini
  4. Pilih file dengan nama App bila ingin melihat program bagian dalam (source code)
  5. Pilih star pada bagian toolbar bagian atas bila ingin menjalankan programnya
  6. Setelah file consolenya dijalankan maka akan muncul sebuah form
  7. Pada form tersebut pada bagian paling atas ada berupa Button yang diberi nama Open File
  8. Libarari baru akan muncul untuk menugaskan Pengguna  atau User untuk memilih file berupa program yang formatnya pascal untuk di Scan dan Parser, pada bagian ini pengguna atau User tidak boleh memilih file program pascal yang berskala berat dalam arti source code banyak, dikarenakan pada program Scanner dan Parser ini memiliki batasan dalam mengparser sebuah file Pascal, maka diharusakan memilih file program pascal yang berada pada bawaan folder dalam program tersebut.
  9. Pilih folder dengan nama Program Untuk di Parser (masih dalam kondisi library kebuka pemilihan file pascal yang akan di parser) klik program Pascalnya dan pilih Open.
  10. File program Pascal  yang User pilih otomatis akan masuk pada bagian form running program parser C# dan tertera juga nama data – data folder riwayat yang user buka ketika memilih file program Pascal yang ingin di Parser tersebut.
  11. Plih Button di bagian bawah dengan nama Scan dank ilk Button tersebut, program yang akan diparser harus di Scan terlebih dahulu sebelum di Parser.
  12. Hasil dari Scan akan muncul berupa Token – token
  13. Setelah Proses Scan telah selesai barulah Button Parsing bisa kita pilih dan klik untuk melanjutkan ketahap Parsing
  14. Maka akan muncul pemberitahuan Nafigasi Parser berhasil dilakukan atau tidak.
Klik Ok misalkan Gagal atau Berhasil utnuk melanjutkan.
  1. Maka hasil dari Parsing pun akan muncul yaitu urutan – urutannya



  1. Pilih folder program folder App kemudian Bin lalu buka folder debug bila ingin menjalankan langsung consolenya pilih file dengan nama App yang berupa gambar console bila ingin menjalankan langsung program Scanner dan Parsernya. tanpa melihat isi dalam dari program tersebut
  2. Bila ingin melakukanya tinggal mengikuti langkah seperti diatas
  3. Bila sudah selesai bisa langsung pilih close atau mau dibersihkan dahulu, yaitu dengan memilih dan klik Button dengan nama Clear All.





















  1. CONTOH TAMPILAN INPUT OUTPUT
D:\TEKOM_KELOMPOK_KOMPILATOR\ss input.PNG
Gambar 1. Input Source File
D:\TEKOM_KELOMPOK_KOMPILATOR\ss scan.PNG
Gambar 2. Proses Scaner
D:\TEKOM_KELOMPOK_KOMPILATOR\ss parse.PNG
Gambar 3. Parsing
  1. GRAMMAR
<program> ::= program <identifier> ; <block> .
<identifier> ::= <letter > {<letter or digit>}
<letter or digit> ::= <letter> | <digit>
<block> ::= <label declaration part> <constant definition part> <type definition part> <variable declaration part> <procedure and function declaration part> <statement part>
<label declaration part> ::= <empty> | label <label> {, <label>} ;
<label> ::= <unsigned integer>
<constant definition part> ::= <empty> | const <constant definition> { ; <constant definition>} ;
<constant definition> ::= <identifier> = <constant>
<constant> ::= <unsigned number> | <sign> <unsigned number> | <constant identifier> | <sign> <constant identifier> | <string>
<unsigned number> ::= <unsigned integer> | <unsigned real>
<unsigned integer> ::= <digit> {<digit>}
<unsigned real> ::= <unsigned integer> . <unsigned integer> | <unsigned integer> . <unsigned integer> E <scale factor> | <unsigned integer> E <scale factor>
<scale factor> ::= <unsigned integer> | <sign> <unsigned integer>
<sign> ::= + | -
<constant identifier> ::= <identifier>
<string> ::= '<character> {<character>}'
<type definition part> ::= <empty> | type <type definition> {;<type definition>};
<type definition> ::= <identifier> = <type>
<type> ::= <simple type> | <structured type> | <pointer type>
<simple type> ::= <scalar type> | <subrange type> | <type identifier>
<scalar type> ::= (<identifier> {,<identifier>})
<subrange type> ::= <constant> .. <constant>
<type identifier> ::= <identifier>
<structured type> ::= <array type> | <record type> | <set type> | <file type>
<array type> ::= array [<index type>{,<index type>}] of <component type>
<index type> ::= <simple type>
<component type> ::= <type>
<record type> ::= record <field list> end
<field list> ::= <fixed part> | <fixed part> ; <variant part> | <variant part>
<fixed part> ::= <record section> {;<record section>}
<record section> ::= <field identifier> {, <field identifier> } : <type> | <empty>
<variant type> ::= case <tag field> <type identifier> of <variant> { ; <variant>}
<tag field> ::= <field identifier> : | <empty>
<variant> ::= <case label list> : ( <field list> ) | <empty>
<case label list> ::= <case label> {, <case label>}
<case label> ::= <constant>
<set type> ::=set of <base type>
<base type> ::= <simple type>
<file type> ::= file of <type>
<pointer type> ::= <type identifier>
<variable declaration part> ::= <empty> | var <variable declaration> {; <variable declaration>} ;
<variable declaration> ::= <identifier> {,<identifier>} : <type>
<procedure and function declaration part> ::= {<procedure or function declaration > ;}
<procedure or function declaration > ::= <procedure declaration > | <function declaration >
<procedure declaration> ::= <procedure heading> <block>
<procedure heading> ::= procedure <identifier> ; | procedure <identifier> ( <formal parameter section> {;<formal parameter section>} );
<formal parameter section> ::= <parameter group> | var <parameter group> | function <parameter group> | procedure <identifier> { , <identifier>}
<parameter group> ::= <identifier> {, <identifier>} : <type identifier>
<function declaration> ::= <function heading> <block>
<function heading> ::= function <identifier> : <result type> ; | function <identifier> ( <formal parameter section> {;<formal parameter section>} ) : <result type> ;
<result type> ::= <type identifier>
<statement part> ::= <compund statement>
<statement> ::= <unlabelled statement> | <label> : <unlabelled statement>
<unlabelled statement> ::= <simple statement> | <structured statement>
<simple statement> ::= <assignment statement> | <procedure statement> | <go to statement> | <empty statement>
<assignment statement> ::= <variable> := <expression> | <function identifier> := <expression>
<variable> ::= <entire variable> | <component variable> | <referenced variable>
<entire variable> ::= <variable identifier>
<variable identifier> ::= <identifier>
<component variable> ::= <indexed variable> | <field designator> | <file buffer>
<indexed variable> ::= <array variable> [<expression> {, <expression>}]
<array variable> ::= <variable>
<field designator> ::= <record variable> . <field identifier>
<record variable> ::= <variable>
<field identifier> ::= <identifier>
<file buffer> ::= <file variable>
<file variable> ::= <variable>
<referenced variable> ::= <pointer variable>
<pointer variable> ::= <variable>
<expression> ::= <simple expression> | <simple expression> <relational operator> <simple expression>
<relational operator> ::= = | <> | < | <= | >= | > | in
<simple expression> ::= <term> | <sign> <term>| <simple expression> <adding operator> <term>
<adding operator> ::= + | - | or
<term> ::= <factor> | <term> <multiplying operator> <factor>
<multiplying operator> ::= * | / | div | mod | and
<factor> ::= <variable> | <unsigned constant> | ( <expression> ) | <function designator> | <set> | not <factor>
<unsigned constant> ::= <unsigned number> | <string> | < constant identifier> < nil>
<function designator> ::= <function identifier> | <function identifier> ( <actual parameter> {, <actual parameter>} )
<function identifier> ::= <identifier>
<set> ::= [ <element list> ]
<element list> ::= <element> {, <element> } | <empty>
<element> ::= <expression> | <expression> .. <expression>
<procedure statement> ::= <procedure identifier> | <procedure identifier> (<actual parameter> {, <actual parameter> })
<procedure identifier> ::= <identifier>
<actual parameter> ::= <expression> | <variable> | <procedure identifier> | <function identifier>
<go to statement> ::= goto <label>
<empty statement> ::= <empty>
<empty> ::=
<structured statement> ::= <compound statement> | <conditional statement> | <repetitive statement> | <with statement>
<compound statement> ::= begin <statement> {; <statement> } end;
<conditional statement> ::= <if statement> | <case statement>
<if statement> ::= if <expression> then <statement> | if <expression> then <statement> else <statement>
<case statement> ::= case <expression> of <case list element> {; <case list element> } end
<case list element> ::= <case label list> : <statement> | <empty>
<case label list> ::= <case label> {, <case label> }
<repetitive statement> ::= <while statement> | <repeat statemant> | <for statement>
<while statement> ::= while <expression> do <statement>
<repeat statement> ::= repeat <statement> {; <statement>} until <expression>
<for statement> ::= for <control variable> := <for list> do <statement>
<control variable> ::= <identifier>
<for list> ::= <initial value> to <final value> | <initial value> downto <final value>
<initial value> ::= <expression>
<final value> ::= <expression>
<with statement> ::= with <record variable list> do <statement>
<record variable list> ::= <record variable> {, <record variable>}

0 Comments

Copyright Jujur Soaloon Sitangang Lipan All rights reserved. Theme by Sitanggang. | Bloggerized by Soalparna.