LAPORAN TUGAS BNF DAN SYNTAX DIAGRAM PADA

BAHASA PEMROGRAMAN C

Mata Kuliah :
Algoritma Pemrograman A (IF 5020)

Oleh :

23520017 Widya Puteri Aulia

23520023 Adi Widayanto
23520037 Lia Anggraini
 Daftar Isi

1. Deskripsi Bahasa Pemrograman

2. Notasi BNF
3. Notasi Diagram Syntax
4. Uji Coba BNF
5. Kesimpulan
1. Deskripsi Bahasa Pemrograman

Bahasa C adalah salah satu general-purpose programming language bahasa ini juga
biasa disebut “System programming language” kerna bahasa ini biasa digunakan untuk
menulis compilers dan operating system.
Bahasa ini juga menyediakan konstruksi control-flow mendasar yang dibutuhkan oleh
program terstruktur. Control-flow tersebut diantaranya :
a. Statement grouping
b. Decision making (if-else)
c. Switch
d. While, for
e. Do yang berada di bawah while,for
f. Loop exit (break)
Fungsi pada C juga dapat dipanggil secara rekursif dengan kemungkinan
mengembalikan nilai return dari tipe mendasar, struktur, union, atau pointer. Local variable
dapat secara “otomatis” atau dibuat dengan masuk atau dibuat dengan invokasi yang baru.
Fungsi dari program C mungkin berada pada pada file terpisah dan di compile secara
terpisah.
Bahasa C tidak menyediakan operasi untuk mengatasi composite object secara
langsung, seperti string, set, list, atau array. Tidak ada operasi yang memanipulasi array atau
string, walaupun strukturnya disalin sebagai unit. Bahasa ini tidak mendefinisikan alokasi
penyimpanan selain definisi statis dan stack dibuat sebagai fungsi dari local variable.
Bahasa C itu sendiri tidak menyediakan input/output; tidak ada pernyataan READ
atau WRITE, dan tidak ada metoda akses file built-in. Semua higher-mechanism ini
disediakan oleh pemanggilan fungsi secara eksplisit. Kebanyakan implementasi C telah
memiliki koleksi standar dari fungsi tersebut.
2. Notasi BNF

Notasi BNF adalah metabahasa yang digunkana untuk menggambarkan tata bahasa
dari bahasa pemrograman. Dibawah ini adalah notasi BNF dari bahasa C yang telah di
definisikan :
2.1 Grammar

2.2 Lexical Conventions

2.2.1 Identifier
2.2.2 Keyword
2.2.3 Constant
<constant> ::= <integer-constant>
| <character-constant>
| <floating-constant>
| <enumeration-constant>
Integer constant
Character constant
Floating constant
Enumeration
2.2.4 String Literal

2.3 Expression
2.3.1 Primary Expression
<primary-expression> ::= <identifier>
 | <constant>
| <string>
| ( <expression> )

2.3.2 Postfix Expression

<postfix-expression> ::= <primary-expression>
| <postfix-expression> [ <expression> ]
|<postfix-expression>({<assignment-expression>}* )
| <postfix-expression> . <identifier>
| <postfix-expression> -> <identifier>
| <postfix-expression> ++
| <postfix-expression> --

2.3.3 Unary Expression

<unary-expression> ::= <postfix-expression>
| ++ <unary-expression>
| -- <unary-expression>
| <unary-operator> <cast-expression>
| sizeof <unary-expression>
| sizeof <type-name>
<unary-operator> ::= &
| *
| +
| -
| ~
| !

2.3.4 Cast Expression

<cast-expression> ::= <unary-expression>
| ( <type-name> ) <cast-expression>

2.3.5 Multiplicative Operators

<multiplicative-expression> ::= <cast-expression>
| <multiplicative-expression> * <cast-expression>
| <multiplicative-expression> / <cast-expression>
| <multiplicative-expression> % <cast-expression>

2.3.6 Additive Operators

 <additive-expression> ::= <multiplicative-expression>
|<additive-expression> + <multiplicative-expression>
|<additive-expression> - <multiplicative-expression>

2.3.7 Shift Operators

<shift-expression> ::= <additive-expression>
| <shift-expression> << <additive-expression>
| <shift-expression> >> <additive-expression>

2.3.8 Relational Operators

<relational-expression> ::= <shift-expression>
| <relational-expression> < <shift-expression>
| <relational-expression> > <shift-expression>
| <relational-expression> <= <shift-expression>
| <relational-expression> >= <shift-expression>

2.3.9 Equality Operators

<equality-expression> ::= <relational-expression>
| <equality-expression> == <relational-expression>
| <equality-expression> != <relational-expression>

2.3.10 Bitwise AND Operators

<and-expression> ::= <equality-expression>
| <and-expression> & <equality-expression>

2.3.11 Bitwise Exclusive OR Operators

<exclusive-or-expression> ::= <and-expression>
| <exclusive-or-expression> ^ <and-expression>

2.3.12 Bitwise Inclusive OR Operators

<inclusive-or-expression> ::= <exclusive-or-expression>
| <inclusive-or-expression> | <exclusive-or-expression>

2.3.13 Logical AND Operators

 <logical-and-expression> ::= <inclusive-or-expression>
| <logical-and-expression> && <inclusive-or-expression>

2.3.14 Logical OR Operators

<logical-or-expression> ::= <logical-and-expression>
| <logical-or-expression> || <logical-and-expression>

2.3.15 Conditional Operators

<conditional-expression> ::= <logical-or-expression>
| <logical-or-expression> ? <expression> : <conditional-expression>

2.3.16 Assignment Expression

<assignment-expression> ::= <conditional-expression>
| <unary-expression> <assignment-operator> <assignment-expression>

2.3.17 Assignment Operators

<assignment-operator> ::= =
| *=
| /=
| %=
| +=
| -=
| <<=
| >>=
| &=
| ^=
| |=

2.3.18 Comma Operators

<expression> ::= <assignment-expression>
| <expression> , <assignment-expression>

2.3.19 Constant Expression

<constant-expression> ::= <conditional-expression>

2.4 Declarations
<declaration> ::= {<declaration-specifier>}+ {<init-declarator>}* ;
<declaration-specifier> ::= <storage-class-specifier>
 | <type-specifier>
| <type-qualifier>
<init-declarator> ::= <declarator>
| <declarator> = <initializer>

2.4.1 Storage Class Specifier

<storage-class-specifier> ::= auto
| register
| static
| extern
| typedef

2.4.2 Type Specifier

<type-specifier> ::= void
| char
| short
| int
| long
| float
| double
| signed
| unsigned
| <struct-or-union-specifier>
| <enum-specifier>
| <typedef-name>
<type-qualifier> ::= const
| volatile

2.4.3 Structure and Union Classifier

<struct-or-union-specifier> ::= <struct-or-union> <identifier> { {<struct-
declaration>}+ }
| <struct-or-union> { {<struct-declaration>}+ }
| <struct-or-union> <identifier>
<struct-or-union> ::= struct
| union
<struct-declaration> ::= {<specifier-qualifier>}* <struct-declarator-list>
<struct-declarator-list> ::= <struct-declarator>
| <struct-declarator-list> , <struct-declarator>
<specifier-qualifier> ::= <type-specifier>
 | <type-qualifier>
<struct-declarator> ::= <declarator>
| <declarator> : <constant-expression>
| : <constant-expression>

2.4.4 Enumeration
<enum-specifier> ::= enum <identifier> { <enumerator-list> }
| enum { <enumerator-list> }
| enum <identifier>
<enumerator-list> ::= <enumerator>
| <enumerator-list> , <enumerator>

<enumerator> ::= <identifier>

| <identifier> = <constant-expression>

2.4.5 Declarators
<struct-declaration> ::= {<specifier-qualifier>}* <struct-declarator-list>
<struct-declarator-list> ::= <struct-declarator>
| <struct-declarator-list> , <struct-declarator>
<specifier-qualifier> ::= <type-specifier>
| <type-qualifier>
<struct-declarator> ::= <declarator>
| <declarator> : <constant-expression>
| : <constant-expression>
<struct-declaration> ::= {<specifier-qualifier>}* <struct-declarator-list>

2.4.6 Function Declarators

parameter-type-list> ::= <parameter-list>
| <parameter-list> , ...

<parameter-list> ::= <parameter-declaration>

| <parameter-list> , <parameter-
declaration>

<parameter-declaration> ::= {<declaration-specifier>}+

<declarator>
| {<declaration-specifier>}+
<abstract-declarator>
| {<declaration-specifier>}+
 2.4.7 Initialization
<initializer> ::= <assignment-expression>
| { <initializer-list> }
| { <initializer-list> , }

<initializer-list> ::= <initializer>

| <initializer-list> , <initializer>

2.4.8 Type name

<type-name> ::= {<specifier-qualifier>}+ {<abstract-declarator>}?
<abstract-declarator> ::= <pointer>
| <pointer> <direct-abstract-
declarator>
| <direct-abstract-declarator>

<direct-abstract-declarator> ::= ( <abstract-declarator> )

| {<direct-abstract-
declarator>}? [ {<constant-expression>}? ]
| {<direct-abstract-declarator>}? (
{<parameter-type-list>}? )

2.4.9 Typedef
<typedef-name> ::= <identifier>

2.5 Statements
<statement> ::= <labeled-statement>
| <expression-statement>
| <compound-statement>
| <selection-statement>
| <iteration-statement>
| <jump-statement>
<labeled-statement> ::= <identifier> : <statement>
| case <constant-expression> : <statement>
| default : <statement>
<expression-statement> ::= {<expression>}? ;
<compound-statement> ::= { {<declaration>}* {<statement>}* }
<selection-statement> ::= if ( <expression> ) <statement>
| if ( <expression> ) <statement> else <statement>
| switch ( <expression> ) <statement>
<iteration-statement> ::= while ( <expression> ) <statement>
 | do <statement> while ( <expression> ) ;
| for ( {<expression>}? ; {<expression>}? ; {<expression>}? ) <statement>
<jump-statement> ::= goto <identifier> ;
| continue ;
| break ;

2.6 External Declaration

<translation-unit> ::= {<external-declaration>}*
<external-declaration> ::= <function-definition>
| <declaration>

2.6.1 Function Definition

<function-definition> ::= {<declaration-specifier>}* <declarator>
{<declaration>}* <compound-statement>
<direct-declarator> ::= <identifier>
| ( <declarator> )
| <direct-declarator> [ {<constant-expression>}? ]
| <direct-declarator> ( <parameter-type-list> )
| <direct-declarator> ( {<identifier>}* )

3. Notasi Diagram Syntax

Pohon diagram syntax (Syntax Tree) berguna untuk menggambarkan bagaimana

memperoleh suatu string dengan cara menurunkan symbol variable menjadi symbol
terminal. Di bawah ini adalah Syntax Tree dari notasi BNF yang telah dibuat :

4. Uji Coba Notasi BNF

4.1 Print Hello World
Source Code
# include <stdio.h>

int main(void)
{
printf ( "hello, world\n" )
}
Penurunan
<translation-unit>::=<external-declaration>          R1
-> <external-declaration>::=<function-definiitoion>                R2
-> <function-definition>::=<declaration-specifier> <declarator> R3
<compound-statement>     
-> <declaration-specifier>::=<type-specifier> <declarator> <compound- R4
statement>
-> <type-specifier>::= int <declarator> <compound-statement> R6
-> <declarator>::= int <direct-declarator> <compound-statement>
-> <direct-declarator> ::= int <direct-declarator> ( <parameter-type-
list> ) <compound-statement>
-> <parameter-list> ::= int <direct-declarator> ( <parameter-
declaration> ) <compound-statement>
-> <parameter-declaration>::=int <direct-declarator> ( <declaration-
specifier> ) <compound-statement>
-> <declaration-specifier>::=int <direct-declarator> ( <type-specifier>
) <compound-statement>
-> <type-specifier>::=int <direct-declarator> (void) <compound-
statement>
-> <direct-declarator>::=int <identifier> (void) <compound-statement>
-> <identifier>::=int <alpha><alpha><alpha><alpha>(void) <compound-
statement>
-> <alpha>::= int m<alpha><alpha><alpha>(void) <compound-statement>
-> <alpha>::= int ma<alpha><alpha> (void) <compound-statement>
-> <alpha>::= int mai<alpha> (void) <compound-statement>
-> <alpha>::= int main(void) <compound-statement>
-> <compound-statement> ::= int main(void) { <declaration>}
-> <declaration>::= int main(void) { <init-declarator> }
-> <init-declaration> ::= int main(void) { <declarator> }
-> <declarator> ::= int main(void) { <direct-declarator> }
-> <direct- declarator> ::= int main(void) { <direct-declarator>
( <identifier> ) }
-> <direct-declarator> ::= int main(void) { <identifier> ( <identifier>
) }
-> <identifier> ::= int main(void)
{ <alpha><alpha><alpha><alpha><alpha><alpha> ( <string> ) }
-> <alpha>::= int main(void) { p<alpha><alpha><alpha><alpha><alpha>
( <string> ) }
-> <alpha>::= int main(void) { pr<alpha><alpha><alpha><alpha>
( <string> ) }
-> <alpha>::= int main(void) { pri<alpha><alpha><alpha> ( <string> ) }
-> <alpha>::= int main(void) { print<alpha> ( <string> ) }
-> <alpha>::= int main(void) { printf ( <string> )

->   int main(void) { printf ( "hello, world\n" ) }

4.2 Menukar Nilai Suatu Variabel
Source Code
#include <stdio.h>
#include <stdlib.h>

int main()
{
int a=3;
int b=2;
int c;
c=a;
a-b;
b=c;
printf("%d",b);
return 0;
}

Penurunan
<translation-unit>::=<external-declaration>         
-> <external-declaration>::=<function-definiitoion>               
-> <function-definition>::=<declaration-specifier> <declarator> <compound-
statement>     
-> <declaration-specifier>::=<type-specifier> <declarator> <compound-
statement>
-> <type-specifier>::= int <declarator> <compound-statement>
-> <declarator>::= int <direct-declarator> <compound-statement>
-> <direct-declarator> ::= int <direct-declarator> ( <parameter-type-list> )
<compound-statement>
-> <direct-declarator>::=int <identifier> (<parameter-type-list>) <compound-
statement>
-> <identifier>::=int <alpha><alpha><alpha><alpha>(<parameter-type-list>)
<compound-statement>
-> <alpha>::= int m<alpha><alpha><alpha>(<parameter-type-list>) <compound-
statement>
-> <alpha>::= int ma<alpha><alpha> (<parameter-type-list>) <compound-
statement>
-> <alpha>::= int mai<alpha> (<parameter-type-list>) <compound-statement>
-> <alpha>::= int main(<parameter-type-list>) <compound-statement>
-> <compound-statement>::=int main(<parameter-type-list>)
{ <declaration><declaration><declaration><statement>* }
-> <declaration>::=int main(<parameter-type-list>) {
 <declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <declaration-specifier>::= int main(<parameter-type-list>) {
<type-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> < type-specifier >::= int main(<parameter-type-list>) {
int <init-declarator>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <init-declarator>::= int main(<parameter-type-list>) {
int <declarator> = <initialize>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <declarator>::= int main(<parameter-type-list>) {
int <identifier> = <initialize>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <identifier>::= int main(<parameter-type-list>) {
int a = <initializer>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <initializer>::= int main(<parameter-type-list>) {
int a = <constant>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <constant>::= int main(<parameter-type-list>) {
int a = <integer-constant>;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <constant>::= int main(<parameter-type-list>) {
int a = 3;
<declaration-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
<declaration-specifier>::= int main(<parameter-type-list>) {
 Int a = 3;
<type-specifier><init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> < type-specifier >::= int main(<parameter-type-list>) {
int a = 3;
int <init-declarator>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <init-declarator>::= int main(<parameter-type-list>) {
int a = 3;
int <declarator> = <initialize>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <declarator>::= int main(<parameter-type-list>) {
int a = 3;
int <identifier> = <initialize>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <identifier>::= int main(<parameter-type-list>) {
int a = 3;
int b = <initializer>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <initializer>::= int main(<parameter-type-list>) {
int a = 3;
int b = <constant>;
<declaration-specifier><init-declarator>;
<statement>*}
-> <constant>::= int main(<parameter-type-list>) {
int a = 3;
int b = 3;
<declaration-specifier><init-declarator>;
<statement>*}
<declaration-specifier>::= int main(<parameter-type-list>) {
int a = 3;
int b = 2;
<type-specifier> <init-declarator>;
<statement>*}
-> < type-specifier >::= int main(<parameter-type-list>) {
int a = 3;
int b = 2;
int <init-declarator>;
<statement>*}
-> <init-declarator>::= int main(<parameter-type-list>) {
 int a = 3;
int b = 2;
int <init-declarator>;
<statement>*}
-> <init-declarator>::= int main(<parameter-type-list>) {
int a = 3;
int b = 2;
int <declarator>;
<statement>*}
-> <identifer>::= int main(<parameter-type-list>) {
int a = 3;
int b = 2;
int c;
<statement>*}

4.3 Menjumlahkan Nilai Variabel

Source code
int main()
{
int a=3;
int b=2;
int c;
c=a;
a-b;
b=c;
printf("%d",b);
return 0;
}

Penurunan
<external-declaration>
Rules 1
 <function-definition>
Rules 2
 <declaration-specifier> <declarator> <compound-statement>
Rules 3
 <type-specifier> <declarator> <compound-statement>
Rules 4
 int <declarator> <compound-statement>
 Rules 6
 int <direct-declarator> <compound-statement>
Rules 13
 int <direct-declarator> ( <parameter-type-list> ) <compound-
statement>
 int <direct-declarator> ( <parameter-list> ) <compound-
statement>
 int <direct-declarator> ( <parameter-declaration> ) <compound-
statement>
 int <direct-declarator> ( <declaration-specifier> ) <compound-
statement>

5. Kesimpulan