SUBPROGRAM DAN IMPLEMENTASINYA Pertemuan 7

SUBPROGRAM DAN IMPLEMENTASINYAPertemuan 7

Matakuliah : KONSEP BAHASA PEMROGRAMANTahun : 2010

Outline Materi• Pendahuluan • Konsep dasar subprogram• Isu desain subprogram• Lingkungan referensi lokal • Metode pengiriman parameter• Parameter yang berbentuk

nama subprogram • Overloaded Subprograms• Generic Subprograms• Isu desain fungsi• User-Defined Overloaded

Operators

• Coroutine• Semantik call dan return• Implementasi ubprograms

sederhana• Implementasi subprogram

dengan variabel lokal stack-dynamik

• Nested Subprograms• Blocks• Implementasi lingkup

dinamik

Bina Nusantara University 3

Pendahuluan• Tipe abstraksi

– Abstraksi proses • Subprogram• Dikenal sejak awal pemrograman• Meningkatkan readability dengan mengekspose struktur logik

sementara detilnya disembunyikan .

– Abstraksi data • TDA • Dikenalkan dalam tahun 80-an• Terdiri dari data dan himpunan operasi• C int : +, -, *, / , %


Fundamental Subprogram• Setiap subprogram mempunyai single entry point• Calling program (caller) ditunda selama eksekusi

subprogram yang dipanggil • Kendali kembali ke caller saat ekseklusi called

subprogram berakhir • Alternatif:

– Co routines, subprogram dengan multi-entries– Concurrent unit – Metode OOP


Definisi• Subprogram definition menguraikan antar-muka ke dan dari subprogram • Subprogram call adalah permintaan eksplisit agar subprogram dieksekusi • Subprogram header adalah bagian pertama dari definisi termasuk nama, tipe

subprogram dan parameter formal – FORTRAN SUBROUTINE ADDER (parameter)– Ada procedure ADDER (parameter)– C void adder (parameter)

• Parameter profile (i.e. signature) dari subprogram adalah banyak, urutan dan tipe parameter

• Protocol adalah parameter profile subprogram dan jika ia fungsi, return type nya.

• Subprogram declaration adalah protocol, tidak termasuk tubuh fungsi, dari subprogram

• Deklarasi fungsi di C dan C++ kerap disebut prototypes


Parameter• Isu

– Akses ke non-lokal: mengurangi reliabilitas, atau – passing parameters: lebih luwes

• Tipe parameter– Formal parameter adalah variabel dummy yang didaftar

dalam subprogram header dan digunakan dalam subprogram

– Actual parameter adalah nilai atau alamat yang digunakan dalam pemanggilan subprogram (call statement)


Korespondensi Parameter Aktual-Formal

• Posisional– Pengikatan parameter aktual ke formal melalui posisinya;

parameter aktual pertama diikat ke parameter formal pertama dan seterusnya.

– Aman dan efektif – Daftar parameter pendek

• Keyword– Nama parameter formal dan formal diikat melalui kata kunci– Daftar parameter panjang – Parameter dapat muncul disembarang lokasi – Harus tahu nama parameter


Nilai default Parameter Formal• Dalam bahasa tertentu (e.g., C++, Ada), parameter

formal dapat mempunyai nilai default yang digunakan jika tidak ada parameter aktual di kirim – Di C++, parameter default harus muncul terakhir karena

parameter adalah positionally associated. Tak ada keyword parameter

– float computePay (float income, float taxRate, int exemption = 1);

• C# dapat menerima banyak parameter bervariasi asalkan mereka sama tipenya.


Prosedur dan Fungsi• Ada dua kategori subprogram

– Procedures adalah koleksi pernyataan yang mendefinisikan komputasi berparameter; diaktifkan dengan pernyataan call ; menghasilkan nilai dengan cara

• Mengubah parameter formal melalui transfer data• Mengubah nonlocal yang bukan parameter formal

– Functions secara struktur mirip prosedur tetapi secara semantik dimodel pada fungsi matematika

• Dipanggil melalui namanya dalam ekspresi • Hasil dikembalikan dan mengganti caller• Diekspektasi tidak ada efek samping • Prakteknya, fungsi mempunyai efek samping


Isu Desain• Apa metode pengiriman parameter yang disediakan? • Apakah tipe parameter di-cek?• Apakah variabel lokal statik atau dinamik?• Dapatkah definisi subprogram muncul dalam definisi subprogram lain?• Dapatkah subprogram di-overload?• Dapatkan subprogram generik?• Kasus di C/C++

– Hanya fungsi tetapi perilaku seperti subprogram/prosedur– Tidak ada nilai balik didefinisikan sebagai void– S and alone call ke fungsi void adalah legal

void sort (int list[ ], int listLen);…sort (scores, 100);


Lingkungan Referensi Lokal• Didefinisikan dalam subprogram • Variabel lokal dapat stack-dynamic

– Keuntungan • Mendukung rekursi • Ruang untuk lokal di-share diantara beberapa subprogram

– Kerugian• Alokasi/de-alokasi, waktu inisialisasi • Pengalamatan tidak langsung • Subprogram tidak dapat history sensitive

• C/C++: lokal adalah stack dynamic kecuali di-declare sebagai statik• Variabel lokal mungkin statik

– Lebih efisien i.e. akses langsung – Tak ada run-time overhead– History sensitive– Tidak mendukung recursion


Metode Pengiriman Parameter• Cara bagaimana parameter di-transmit ke

dan/atau dari subprogram – Pass-by-value (mode in)– Pass-by-result (mode out)– Pass-by-value-result (mode inout)– Pass-by-reference (mode inout)– Pass-by-name (mode inout)


Model Pengiriman Parameter


Pass by Value• Nilai parameter aktual digunakan untuk

inisialisasi parameter formal pasangannya. – Biasanya diimplementasikan melalui copying. – Data aktual di-transfer sehingga akses lebih efisien – Dapat diimplementasikan dengan mengirim jalur akses

tetapi tidak dianjurkan – Jika copy digunakan, dibutuhkan tambahan ruang– Costly, i.e. tambahan ruang dan operasi copy


Pass by Result• Jika parameter di passed by result, tak ada nilai dikirim ke subprogram;

lokal dikirim balik ke caller• Parameter formal pasangannya berlaku sebagai variabel lokal; nilainya

dikirim balik ke parameter aktual saat kendali dikembalikan ke caller. – Membutuhkan ruang tambahan dan operasi copy

• Potensi masalah: parameter aktual collisionprocedure sub (y: int, z: int)…sub(p1, p1);

apapun parameter formal yang di-copy balik akan menjadi nilai p1nilai p1 tergantung pada urutan assignment di return; masalah portabilitas

• Dua waktu berbeda untuk evaluasi alamat aktual – Pada waktu call, atau– Padawaktu return


Pass by Value-Result• Kombinasi pass-by-value dan pass-by-result• Aktual di-copy ke formal dan kemudian copy

balik.• Kadang-kadang disebut pass-by-copy• Parameter formal mempunyai local storage• Kerugian :

– Sama dengan pass-by-result dan pass-by-value


Pass by Reference• Kirim jalur akses biasanya alamat • Aktual di-share sehingga disebut pass-by-sharing• Proses pengiriman efisien (waktu, ruang, tak ada

copying dan tak ada duplikasi storage)• Kerugian

– Akses lambat, dibandingkan dengan pass-by-value, ke parameter formal

– Potensi terjadi efek samping yang tak diinginkan – Potensi alias yang tak diinginkan


Pass by Reference (lanjutan)• Meng-create alias

– Parameter aktual collisions• void fun(int* first, int* second);• fun(&total, &total);• first dan second akan aliases

– Elemen array collisions• fun(&list[i], &list[j]); // if i=j

– Collision antara elemen array dan elemen array yang di-pass sebagai nama array

• Fun1(&list[i], &list);

– Collision antara formal dan non-local


Pass by Reference (lanjutan)• int* global; void sub(int* local){

void main() { extern int* global; extern int* global; … … } sub(global);}

• Dalam sub, lokal dan global adalah aliases• Kerugian dengan aliases: mengganggu readability sehingga

mengganggu reliability• Gunakan pass by value result bukannya pass by reference

untuk menghilangkan aliases


Pass by Name• Substitusi tekstual ke formal• Formal diikat ke metode akses saat call, tetapi pengikatan aktual ke

nilai atau alamat terjadi saat referensi atau penugasan• Memungkinkan fleksibilitas dalam late binding

– Pengikatan dinamik dan polimorfisme (OOPL)– Lazy evaluation

• Evaluasi short circuit dari B-ekspresi • Evaluasi semua ekspresi di bahasa fungsional Haskel

• Semantiks– Jika aktual skalar, pass by reference– Jika aktual adalah ekspresi konstan, pass by value– Jika aktual elemen array, like nothing else– Jika aktual adalah ekspresi yang memuat variabel, like nothing else


Implementasi Pengiriman Parameter• Dalam kebanyakan bahasa komunikasi

parameter terjadi melalui run-time stack• Pass-by-reference yang paling sederhana untuk

diimplementasikan; hanya alamat yang perlu diletakkan di stack

• Eror fatal mungkin terjadi dengan pass-by-reference dan pass-by-value-result: parameter formal yang berpasangan dengan konstanta dapat secara tak sengaja diubah


Implementasi Pengiriman Parameter (lanjutan)

• Fortran– Selalu menggunakan model semantik inout – Sebelum Fortran 77: pass-by-reference– Fortran 77 dan berikutnya: skalar kerap menggunakan passed by value-result

• C– Pass-by-value– Pass-by-reference dilakukan menggunakan pointers sebagai parameters tetapi

tak ada yang dikirim balik • C++

– Tipe pointer khusus disebut reference untuk pass-by-reference; de-referensi secara implisit

• Java– Semua parameter di passed by value– Parameter object di passed by reference– Skalar tak dapat di passed by reference karena variabel reference tak dapat

menunjuk skalar dan Java tidak punya pointer


Implementasi Pengiriman Parameter (lanjutan)

• Ada– Tiga mode semantik pengiriman parameter : in, out, in out;

mode default adalah in – Parameter formal yang di-declare out dapat di-assign tetapi

tidak direferensi; yang di-declare in dapat direferensi tetapi tidak di-assign; parameter in out dapat direferensi dan di-assign

• C#– Metode default : pass-by-value– Pass-by-reference dispesifikasi dengan cara parameter formal

dan aktual didahului dengan ref• PHP: sangat mirip dengan C#• Perl: semua parameter aktual secara implisit diletakkan

dalam predefined array named @_


Pencekan Tipe Parameter• Sangat penting untuk reliability• FORTRAN 77 dan C asli : tidak • Pascal, FORTRAN 90, Java, dan Ada: selalu

diperlukan • ANSI C dan C++: pilihan dibuat oleh pengguna

– Prototipe

• Bahasa-bahasa baru seperti Perl, JavaScript, dan PHP tidak memerlukan pencekan tipe


Array Multidimensi sebagai Parameter• Jika array multidimensi dikirim ke subprogram dan subprogram dikompail

secara terpisah, kompilator perlu mengetahui ukuran array yang dideklarasikan untuk menentukan ruang untuk fungsi pemetaan

• Kasus di C/C++– Pemrogram diharuskan untuk memasukkan semua ukuran deklarasi

kecuali subskrip pertama dalam parameter aktual; untuk array dua dimensi kita perlu tahu banyak kolom bukannya banyak baris

– Masalah : Tidak memungkinkan menulis fungsi yang dapat menerima array dengan banyak kolom berbeda sehingga tidak memungkinkan menulis program yang luwes.

– Solusi: kirim pointer ke array dan ukuran dimensi sebagai parameter yang lain; pengguna harus memasukkan storage mapping function menggunakan aritmatika pointer


Array Multidimensi sebagai Parameter di sejumlah bahasa

• Pascal– Tak ada masalah karena ukuran deklarasi adalah bagian dari tipe array

• Ada– Constrained arrays – seperti Pascal– Unconstrained arrays – ukuran deklarasi adalah bagian dari deklarasi obyek

• Fortran– Parameter formal yang dipunyai array dideklarasi sesudah header– Untuk array dimensi satu, subscript tidak relevan – Untuk array multi-dimensi , subscripts menentukan storage-mapping function

• Java dan C# : mirip ada– Array adalah obyek; mereka semua adalah dimensi satu tetapi elemennya dapat

berupa array – Setiap array mewarisi named constant (length di Java, Length di C#) yang di-set ke

panjang array saat obyek array di-create


Isu Desain Pengiriman Parameter• Dua pertimbangan utama

– Efisiensi – Transfer data: one-way atau two-way

• Tetapi ada konflik pada pertimbangan di atas– Pemrograman yang baik menganjurkan akses terbatas

pada variabel, yang berarti jika mungkin one-way – Tetapi pass-by-reference lebih efisien untuk mengirim

struktur yang ukurannya signifikan


Parameter berbentuk Nama Subprogram

• Kadang-kadang menyenangkan untuk mengirim nama subprogram sebagai parameter

• Isu:1. Apakah parameter dicek tipenya?2. Apa lingkungan referensi yang benar untuk

subprogram yang dikirim sebagai parameter?


Parameter berbentuk Nama Subprogram: Pencekan Tipe

• C dan C++: fungsi tak dapat dikirim sebagai parameter tetapi pointer ke fungsi dapat dikirim; parameter dapat dicek tipenya

• FORTRAN 95 cek tipe • Pascal versi akhir dan Ada tidak membolehlan

subprogram sebagai parameter; sebagai alternatif diberikan melalui fasilitas Ada’s generik


Parameter berbentuk Nama Subprogram: Lingkungan Referensi

• Shallow binding: Lingkungan pernyataan call yang mempengaruhi pengiriman subprogram

• Deep binding: Lingkungan dari definisi subprogram yang dikirim

• Ad hoc binding: Lingkungan dari pernyataan call yang mengirim subprogram


Overloaded Subprogram• Overloaded subprogram adalah subprogram yang mempunyai

nama yang sama dengan subprogram lain dalam lingkungan referensi yang sama. – Setiap versi overloaded subprogram mempunyai protokol unik, i.e.

harus berbeda dari yang lain dalam hal banyak, urutan atau tipe parameter atau tipe nilai balik jika berbentuk fungsi.

• C++, Java, C#, dan Ada mencakup predefined overloaded subprograms

• Di Ada, tipe balik dari overloaded function dapat digunakan untuk tidak membingungkan calls (jadi dua overloaded functions dapat mempunyai parameter yang sama)

• Ada, Java, C++, dan C# memungkinkan pengguna untuk menulis banyak versi subprogram dengan nama yang sama


Subprogram Generik• Generic atau polymorphic subprogram

mempunyai tipe parameter berbeda pada aktivasi berbeda

• Overloaded subprogram adalah ad hoc polymorphism

• Subprogram yang mempunyai generic parameter yang digunakan dalam ekspresi yang menguraikan tipe parameter subprogram adalah parametric polymorphism


Polimorfisme Parametrik : C++• template <template parameter>

– Definisi fungsi yang mencakup template parameter

template <class Type>Type max(Type first, Type second) { return first > second ? first : second;}

• Template di atas dapat di-instantiate untuk sembarang tipe untuk mana operator > didefinisikan

int max (int first, int second) {return first > second? first : second;

}


Isu Desain Fungsi• Apakah efek samping dimungkinkan?

– Parameter seharusnya selalu mode in untuk mengurangi efek samping seperti Ada

• Tipe nilai balik apa yang dibolehkan?– Kebanyakan bahasa imperatif membatasi tipe balik– C membolehkan sembarang tipe kecuali array dan fungsi – C++ seperti C tetapi juga membolehkan tipe user-defined– Ada membolehkan sembarang tipe – Java dan C# tidak punya fungsi tetapi method dapat

mempunyai sembarang tipe


Operator Overloaded User-Define• Operator dapat di-overload di Ada dan C++• Contoh Ada

Function “*”(A,B: in Vec_Type): return Integer is

Sum: Integer := 0;

begin

for Index in A’range loop

Sum := Sum + A(Index) * B(Index)

end loop

return sum;

end “*”;

…

c = a * b; -- a, b, and c are of type Vec_Type


Co-routine• Coroutine adalah subprogram yang mempunyai multiple entries

dan mengkontrol dirinya sendiri • Juga disebut symmetric control: caller dan called coroutines

adalah setara basisnya • A coroutine call disebut resume• Resume pertama adalah keawal coroutine, tetapi call berikutnya

masuk di titik sesudah pernyataan terakhir yang dieksekusi dalam coroutine

• Coroutine mengulangi resume satu sama lain, mungkin seterusnya

• Coroutines menyediakan quasi-concurrent execution dari unit program (the coroutines); ekselusinya interleave, tetapi tidak overlapped


Ilustrasi Co-routine (1)






Semantik Call dan Return• Operasi subprogram call dan return suatu

bahasa bersama-sama disebut subprogram linkage

• Subprogram call mempunyai berbagai aktivitas yang berasosiasi dengannya yaitu – Metode pengiriman parameter– Variabel lokal statik – Eksekusi status calling program– Transfer kendali – Subprogram nesting


Semantik Call dan Return Program Sederhana

• Call– Simpan status eksekusi dari caller– Lakukan proses pengiriman parameter– Kirim alamat kembali ke callee– Transfer kendali ke callee

• Return– Jika digunakan pass-by-value-result, kirim nilai parameter formal ke

parameter aktual pasangannya. – Jika fungsi , kirim nilai fungsi ke tempat caller dapat mengakssesnya – Restore status eksekusi dari caller– Transfer kendali kembali ke caller


Implementasi Suprogram Sederhana• Dua bagian terpisah : bagian kode aktual dan

nonkode (variabel lokal dan data yang dapat diubah)

• Format dari bagian nonkode yang dieksekusi disebut activation record

• Activation record instance (ARI) adalah contoh kongkrit dari record aktivasi (koleksi data untuk aktivasi subprogram tertentu)

• Record aktivasi subprogram sederhana


Kode dan Record Aktivasi Subprogram Sederhana

• Kode dan record aktivasi program sederhana


Implementasi subprogram dengan variabel lokal stack-dynamic

• Record aktivasi lebih kompleks – Kompilator harus men-generate kode untuk melakukan

alokasi dan de-alokasi variabel lokal secara implisit – Rekursi harus didukung dengan menambah peluang

aktivasi multiple subprogram secara simultan


Tipikal Record Aktivasi dengan Variabel Lokal Stack-Dynamic


Record Aktivasi dengan Variabel Lokal Stack-Dynamic

• Format record aktivasi adalah statik tetapi ukurannya mungkin dinamik

• Dynamic link menunjuk top ARI caller• ARI dibentuk secara dinamik saat subprogram

dipanggil • Run-time stack


Contoh Fungsi Cvoid sub(float total, int part)

{

int list[4];

float sum;

…

}


Contoh Tanpa Rekursivoid A(int x) {

int y;...C(y);...

}void B(float r) {

int s, t;...A(s);...

}

void C(int q) {...

}void main() {

float p;...B(p);...

}


Contoh tanpa Rekursi


Rangkaian Dinamik dan Ofset Lokal• Koleksi dari link dinamik dalam stack disebut

dynamic chain, atau call chain• Variabel lokal dapat diakses melalui ofsetnya

dihitung mulai dari awal record aktivasi. Ofset ini disebut local_offset

• Local_offset dari variabel lokal ditentukan oleh kompilator saat kompilasi


Contoh dengan Rekursi• Record aktivasi yang digunakan di contoh sebelumnya

mendukung rekursi, e.g.

int factorial (int n) { <-----------------------------1 if (n <= 1) return 1; else return (n * factorial(n - 1)); <-----------------------------2 } void main() { int value; value = factorial(3); <-----------------------------3 }


Record Aktivasi Faktorial


Subprogram Nested• Beberapa bahasa bukan basis C lingkup statik

(e.g., Fortran 95, Ada, JavaScript) menggunakan stack-dynamic local variables dan membolehkan subprogram di-nested

• Semua variabel yang dapat diakses secara non-lokal menetap dalam beberapa ARI dalam stack

• Proses melokalisasi variabel non-local 1. Cari ARI yang benar 2. Tentukan ofset dalam ARI


Menentukan Lokasi Non-lokal• Mudah menemukan ofset • Menemukan ARI yang benar

– Aturan statik semantik menjamin bahwa variabel non-lokal yang dapat dirujuk telah dialokasikan disuatu ARI yang berada dalam stack ketika referensi dilakukan


Static Scoping• Static chain adalah rangkaian static links yang

menghubungkan ARI tertentu • Static link dalam ARI untuk subprogram A

menunjuk ke ARI static parent A• Static chain dari ARI menghubungkannya ke

semua static ancestors-nya


Contoh Pascalprogram MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB1; var A, D : integer; begin { SUB1 } A := B + C; <-----------------------1 end; { SUB1 } procedure SUB2(X : integer); var B, E : integer; procedure SUB3; var C, E : integer; begin { SUB3 } SUB1; E := B + A: <--------------------2 end; { SUB3 } begin { SUB2 } SUB3; A := D + E; <-----------------------3 end; { SUB2 } begin { BIGSUB } SUB2(7); end; { BIGSUB } begin BIGSUB; end; { MAIN_2 }


Contoh Pascal (lanjutan)• Sekuen call untuk MAIN_2

MAIN_2 calls BIGSUB BIGSUB calls SUB2 SUB2 calls SUB3 SUB3 calls SUB1


Isi Stack di Posisi 1


Display• Alternatif dari static chains• Static links disimpan di array tunggal yang

disebut display• Isi dari display pada suatu waktu adalah daftar

alamat ARI yang dapat diakses


Blok• Blok adalah lingkup variabel lokal yang dispesifikasi oleh user • Contoh dalam C{int temp; temp = list [upper]; list [upper] = list [lower]; list [lower] = temp}

• Lifetime dari temp di program di atas mulai saat kendali masuk ke blok

• Keuntungan menggunakan variabel lokal seperti temp adalah ia tidak dapat diintervensi oleh variabel lain dengan nama yang sama


Implementasi Blok• Dua metode :

1. Perlalukan blok sebagai subprogram tanpa parameter yang selalu dipanggil dari lokasi yang sama – Setiap blok mempunyai record aktivasi; ARI dibentuk

setiap kali blok dieksekusi

2. Karena ruang maksimum yang dibutuhkan blok dapat ditentukan secara statik, ruang ini dapat dialokasikan sesudah variabel lokal dalam record aktivasi


Implemantasi Dynamic Scoping• Deep Access: referensi non-local dapat

ditemukan dengan pecarian di ARI dalam dynamic chain

• Shallow Access: letakkan lokal di central place– Satu stack untuk setiap nama variabel – Central table dengan entri masuk untuk setiap nama

variabel


Shallow Access untuk Dynamic Scoping


LATIHANA. SOAL PILIHAN 1. Kerugian dari penggnaan keyword parameter adalah

– user harus tahu nama parameter formal– user harus tahu tipe parameter formal– user harus tahu posisi parameter formal– user harus tahu nilai parameter formal

2.Pass by copy adalah nama lain dari a. pass by value b. pass by resultc. pass by value-result d. pass by reference

3.Overloaded subprogram juga dikenal dengan nama a. trivial polymorphism b. squasi polymorphismc. parametric polymorphism d. ad hoc polymorphism


LATIHAN4. Subprogram linkage meliputia. subprogram call dan return b. return dan activation recordc. activation record dan subprogram calld. subprogram call, return dan activation record.

5. Pasangan yang digunakan untuk menunjukan referensi aktual nonlokal variable di bahasa static scope adalaha. (static depth, nesting depth) b. (chain offset, local offset)c. (static depth, local offset) d. (nesting depth, chain offset).


LATIHANB. SOAL URAIAN

1. Ada dua cara subprogram mengakses data yaitu direct access variable nonlocal dan passing parameter. Jelaskan mengapa passing parameter lebih flexible daripada akses nonlokal data.

2. Uraikan apa beda antara– overloaded operator vs overloaded subprogram– ad hoc polymorphism vs parametric polymorphism – separate vs independent compilation


Ringkasan• Definisi subprogram menguraikan aksi yang disajikan oleh

subprogram• Subprogram mungkin fungsi atau prosedur • Variabel lokal dalam subprogram dapat stack-dynamic atau static• Tiga model pengiriman parameter: in mode, out mode, dan inout

mode• Sejumlah bahasa membolehkan operator overloading• Subprogram dapat generic• Coroutine adalah subprogram khusus dengan multiple entries• Semantik subprogram linkage memerlukan banyak aksi dengan

cara implementasi• Subprogram sederhana relatif hanya aksi dasar


Ringkasan (lanjutan)• Bahasa stack-dynamic lebih kompleks• Subprogram dengan stack-dynamic local variables dan nested

subprograms mempunyai dua komponen– Kode aktual – Record aktivasi

• ARI memuat parameter formal dan variabel lokal bersama yang lain

• Static chains adalah metode utama dari implementasi untuk mengakses variabel non-lokal dalam bahasa static-scope dengan nested subprograms

• Akses ke variabel non-lokal di bahasa dynamic-scope dapat diimplementasikan dengan menggunakan dynamic chain atau melalui beberapa variabel tengah metode tabel (display)


Documents

SUBPROGRAM DAN IMPLEMENTASINYA Pertemuan 7