Phases of Compiler

Programming කරන අයගෙනුත් ඉතා සුළු පිරිසක් තමයි අපි program එකක් ලියල compile කරල run කලාම machine එක ඇතුලෙදි compiler එකෙන් මොකක්ද වෙන්නේ කියල දන්නේ ඉතින් මම අද කියන්ඩ යන්නේ අපි source code එකක් run කලාම එකට machine එක ඇතුලෙදි මොකද වෙන්නේ කියල එහෙනම් අපි වැඩේට බහිමු.

මුලින්ම පැහැදිලි කරන්ඩ ලේසි වෙන්ඩ මම code එකට වෙන දේවල් ටික සරලව පැහැදිලිව බලන්ඩ පුළුවන් රුපයක් පහලින් දාන්නම් එක මුලින්ම හොදට බලන්ඩකෝ.ඊට පස්සේ බලමු මේ එකින් එක මොකද වෙන්නේ කියල.

Lexical Analyser 

මුලින්ම අපි ලියපු source code එක යන්නේ lexical analyzer හරහා මේක හරහා යන source code එකේ තියන wide space , comments එහෙම නොසලකා හැරල source code එක tokens වලට වෙන් වෙනවා දැන් කට්ටිය බලනවා ඇති මොනවද මේ tokens කියල tokens කියන්නේ සමුහයක් විදිහට එකතු කරල ගත්තම මොකක් හරි තේරුමක් තියන වචන අනුපිලිවලකට.දැන් අපි උදාහරණයක් අරගෙනම බලමු මේ ක්‍රියාවලිය වෙන්නේ කොහොමද කියල.

Ex :-                      newvalue = oldvalue + rate * 60

මෙන්න මේ tokens ටික හදන්නේ lexical analyzer එකෙන් තමයි.

Syntax Analyser

මෙන්න මෙතැනදී තමයි අපි ලියපු program එකට අදාල parse tree එක හැදෙන්නේ දැන් කට්ටිය බලනවා ඇති parse tree කියන්නේ මොකක්ද කියල එක ටිකක් ලොකු කතාවක් ඒකනිසා ඒගැන වෙනම post එකකින් කතා කරන්නම් දැනට මේ කියන්නේ මොකක්ද කියල තේරුම් ගන්ඩ පොඩ්ඩක් පැහැදිලි කරල දෙන්නම්.

ඕනෑම භාෂාවක් ගත්තම අපි එක පාවිච්චි කරන්නේ මොකක හරි grammar එකකට අදාලව ඒ කිව්වේ නීති රීති වලට අනුකුලව ඉතින් programming language එකක් ගත්තත් එකේ වෙනසක් නැ අපි ඒක පාවිච්චි කරන්නේ grammar එකකට අනුව ඉතින් parse tree කියන්නේ අන්න ඒ grammar එක නිරුපනය කරන්ඩ අදින tree එකකට කියල දැනට මතක තියාගන්ඩ. parse tree එකකින් program එකක syntactic representation එක තමයි අපිට නිරුපනය කරන්ඩ පුළුවන් ඒ කිව්වේ හරියට grammar use කරලද කියන එක. හරි දැන් අපි බලමු lexical analyzer එකෙන් හැදුන tokens එකතු කරගෙන syntax analyzer එකෙන් ඉහත උදාහරණයට අදාල parse tree එක හැදෙන්නේ කොහොමද කියල.

syntax analyzer එකෙන් මෙන්න මේ tree එක හදල ඉතුරු වැඩ වලට semantic analyzer එකට බාරදෙනවා.

Semantic Analyzer

දැන් syntax analyzer එකෙන් program එක grammatically correct කරල තියෙන්නේ ඉතින් semantic analyzer එකෙන් කරන්නේ program එකේ ලියල තියන දේවල් meaningful ද කියල බලන එක (Semantically verify). මේක තේරුම් ගන්ඩ English වල example එකක් දෙන්නම් එතකොට හොදට තේරෙයි.

• snake is mammal. (grammatically correct උනාට meaningful නැ)
• snake not mammal is. (grammatically correct නැ වගේම meaningful නැ)
• snake is a reptile.(grammatically correct වගේම meaningful) 

දැන් තේරෙනවා නේද semantically verify කරනවා කියන්නේ මොකක්ද කියල.

Intermediate Code Generator(ICG)

නමින්ම තේරෙනවනේ මෙතන මොකක්ද වෙන්නේ කියල මෙතැනදී intermediate code එකක් generate වෙනවා දැන් අපි බලමු මොකක්ද මේ කියන code එකේ වැදගත්කම කියල දැන් අපි මෙතනට එනකන් කතා කරපු හැම step එකක්ම platform independent කියපු එක තේරුනේ නැ නේද ඒ කිව්වේ හිතන්දකෝ අපිට ඕනි අලුතින් compiler එකක් design කරන්ඩ කියල එහෙමනම් අපිට මුල ඉදලම design කරන්ඩ ඕනි නැ මෙතන step එකට එනකම් ඕනිම compiler එකක් සමානයි අපි අලුතින් design කරන්ඩ ඕනි මෙතනි එහෙට තියන step ටික විතරි.

මෙන්නේ මේ ICG එකේ තවත් වැදගත් කම් ටිකක තියනවා මම අ ටිකත් කෙටියෙන් කියන්නම් එකක් තමි intermediate code එක හදාගත්තට පස්සේ target program එකට translate කරගන්ඩ ලේසියි ඒවගේම තමයි මේක නිසා memory efficient ඒ කිව්වේ memory ඉතුරුකරගන්ඩ පුළුවන් මොකද මේකෙන් අපිට පුළුවන් උසේ කරන්ඩ පුළුවන් අවම memory addresses ගැන වෙනකන් program එක අඩු කරගන්ඩ.දැන් බලමු ඉහත උදාහරණයට හැදෙන intermediate code එක මොන වගේද කියල.

එක එක වර්ගයේ intermediate code තියනවා ඒ උනාට ගොඩක් තැන්වලදී වගේම මෙතනදීත් අපිට ඇවිත් තියෙන්නේ 3 address code එකක් එකේ තේරුම තමයි හැම expression එකකම use වෙලා තියෙන්නේ address 3 විතරයි. ඔය හේතුව නිසා තමයි මම කිව්වේ මේකෙන් memory efficient වෙනවා කියල එතකොට ඕනිම program එකක් registers 3 විතරක් use කරල run කරගන්ඩ පුළුවන්. මෙතනට එනකන් step ටිකට අපි කියනවා front end කියල මෙතනින් එහාට තියන step ටිකට අපි කියන්නේ compiler phase වල back end එක කියල.

Code Optimiz

මෙකෙන්නම් එච්චර ලොකු වැදගත් දෙයක් වෙන්නේ නැහැ මේකෙන් වෙන්නේ intermediate code generator එකෙන් හැදුන code එකේ වැඩිපුර line තියනවනම් ඒවා ඓන් කරල code එක optimize කරන එක.මේ සේරම කරල අවදානයට බාරදෙන්නේ code generator එකට.

Code Generator 

මෙතනට optimize වෙලා ආපු code එක එකට සමාන machine language එකට translate වෙන එක තමයි වෙන්නේ.ඊට අමතරව තවත් වැදගත් වැඩ කීපයක් මෙතැනදී වෙනවා ඒවා තමයි.

• program එක run වෙන්ඩ අවශ්‍ය data structure එක create කරන එක.
• program එකේ උසේ වෙන variable වලට අවශ්‍ය memory location select කරනවා.

ඔන්න ඔහොම තමයි අපි program එකක් ලියල run කරහම අ program එකෙන් අපිට ඕනි කරන දේ වෙනකන් process වෙන්නේ හිතනවා හැමෝටම තෙරුම්යන්ඩ ඇති කියල වැරදි තියෙන්ඩත් පුලවන් එහෙම වැරද්දක් තියනවා දැක්කොත් comment එකක් දාල support එකක් දෙන්ඩ එහෙනම් තවත් post එකකින් හමුවෙමු හැමෝටම ජය වේවා .....!!!!!

Java Data Types And Variable Types

ඔන්න එහෙනම් කිව්වා වගේම java වල තවත් වැදගත් කොටසක් ගැන කියන්ඩ කියල හිතුව එක තමයි data type සහ variable types ගැන එහෙනම් වැඩේ පටන් ගම්මු.

Data Types

මම කලින් post එකේදී කිව්වා java කියන්නේ compile language එකක් කියල අපි ලියන code එක compile වෙනකොට compiler එකෙන් අපේ code එකේ තියන data store කරගන්ඩ compile time එකේදී memory allocate කරනවා ඉතින් එහෙම memory allocate කරනකොට මේ data එකට මෙච්චරක් allocate කරන්ඩ ඕනි මේ data එකට මෙච්චරක් allocate කරන්ඩ ඕනි කියල compiler එක දන්නේ නැ අන්න ඒ වෙලාවට තමි අපිට data type කියන එක වැදගත් වෙන්නේ එක නිසා අපි java වලින් programme එකක් ලියනවනම් එකේ ඇතුලේ අපි ලියන හැම data එකම data type එකත් එක්ක ලියන්ඩ ඕනි

java language එකේ data type වර්ග දෙකක් තියනවා primitive data type සහ object data type කියල අපි දැන් බලමු එකින් එකට තියන වෙනස්කම් මොනවද කියල..

primitive data types

primitive data type කියන්නේ මුලික data type වලට ඒ කිව්වේ තවදුරටත් කුඩා කොටස් වලට කැඩිය නොහැකි data. අපි සාමාන්යෙන් මේවගේ type use කරන්නේ ප්‍රමාණයෙන් කුඩා data එකක් store කරගන්ඩ උදාහරණයකට ඉලක්කම්, true, false value එකක් store කරන්ඩ වගේ.මේ ආකාරයේ primitive data type 8 java වල තියනවා.

• byte                         
• short
• int
• long
• float
• double
• char
• boolean

අපි දැන් බලමු මේ එක් එක් data type එකේ store කරන්ඩ පුලුවන් මොන වගේ data ද , කොච්චර memory ප්‍රමාණයක් store කරන්ඩ පුල්වන්ද කියා පොඩි පොඩි කරුණු ටිකක්.ලේසියට මම ඒ ටික පොඩි table එකකින් දාන්නම්.

object data type 

object data type එකක අපිට primitive type එකකට වඩා වැඩි data ප්‍රමාණයක් store කරන්ඩ පුළුවන්.object data type එක හැදෙන්නේ primitive data type කීපයක එකතුවකින් වෙන්ඩත් පුළුවන්.

හරි දැන් java data type ගැන දැන ගත්තනේ ඊළගට අපි තවත් වැදගත් මාතෘකාවකට බහිමු ඒ තමයි variable types. හරි එහෙනම් බලමු මොනවද මේ variable type කියන්නේ කියල.

Methods

java language එක ගත්තම ඒ ඒ variable එක තියන තැන අනුව variable type 4 ට බෙදල තියනවා දැන් අපි මේ එකින් එක උදාහරණ එක්කම අරන් බලමු.

1.method local variable

අපි variable එකක් method එකක් ඇතුලේ ලියල තියනවනම් ඒ වගේ variable එකකට තමයි method local variable කියන්නේ නම කියපු ගමන් ඒක තේරෙනවනේ. මේවගේ variable එකක් අපි හැදුවොත් අනිවාර්යෙන්ම value එකක් assign කරන්ඩම ඕනි.හරි දැන් අපි උදාහරණයක් බලමු.

පොඩි දෙයක් කියන්ඩ අමතක උන ඒක අව්ලක් වෙන්නේ නැ දැන් මතක තිය ගන්ඩකෝ java වල variable එකක් declare කරලා assign කරන්නේ (int i=10;) විදිහට කියල ඔය i කියන්නේ variable එකේ name එක int කියන්නේ අර කලින් කතා කරපු data type එක 10 කියන්නේ value එක. හරි දැන් මේ උදාහරනේ i කියන variable එක තියෙන්නේ main method එක ඇතුලේ මම ඊයේ කිව්වනේ main method එකත් normal method එකක් වගේමයි කියල ඉතින් method එක ඇතුලේ තියන නිසා මේක method local variable එකක්.මෙවැනි variable එකක් වලංගු වෙන්නේ method එක ඇතුලට විතරයි method එක එළියේ ඉදල access කරන්ඩ බැ.

2.block variable

මේකෙත් කියන්ඩ තරම් ලොකු වෙනසක් නැ method local වගේම තමයි අපි block එකක් ඇතුලේ variable එකක් හැදුවොත් එක block variable එකක් වෙනවා. මෙතැනදී එක වැදගත් දෙයක් කියන්ඩ තියනවා block variable එකක් වලංගු වෙන්නේ ඒ block එක ඇතුලට විතරයි.උදාහරණයක් පෙන්නුවහම හොදට තේරෙයි.

හරි දැන් දැක්කම බය වෙනද එපා ඔය දාල තියෙන්නේ for loop එකක් ඒ ගැන මම පස්සේ කතා කරන්නම්.for loop එක කියන්නේ යම්කිසි block එකක් ඉතින් ඔය i කියන variable එක define කරලා තියෙන්නේ අන්න ඒ block එක ඇතුලේ ඉතින් එක නිසා අපි i block variable එකක් කියල හදුන්වනවා.කලින් එක වගේමයි ලොකු වෙනසක් නැ.

3.static variable

මේකනම් කලින් දෙකට වඩා පොඩි වෙනසක් තියනවා අපි method එකකින් එළියේ ඒ උනාට class එකක් ඇතුලේ static කියන keyword එකත් එක්ක define කරන variable එකකට static variable එකක් කියනවා. මම main method එක ගැන කියනකොට කිව්වා නේද static keyword එක දාන්නේ අනිත් ඒවාට කලින් RAM එකට load වෙනඩ කියල මෙතනදීත් ඒක එහෙම්ම තමයි මේ static variable කලින් කිව්වා ඒවාට වඩා වෙනස් වෙන්නේ මේක load වෙන්නේ RAM එකට ඒක නිසා අපිට static variable ඒ class එකේ ඕනි තැනක ඉදල access කරන්ඩ පුළුවන්. දැන් අපි උදාහරණයක් බලමු.

4.instance variable

instance variable එකක් define කරන්නෙත් method එකකින් එළියේ class එකක් ඇතුලේ static වලින් වෙනස් වෙන්නේ මේක define කරනකොට static keyword එක දන්නේ නැ.මේකෙත් තියනවා වෙශේෂත්වයක් මම කිව්වනේ මේවා තියෙන්නේ class එකක් ඇතුලේ කියල මේ instance variable එකක් stack එකට load වෙන්ඩනම් ඒ class එකෙන් object එකක් හදන්දම ඕනි නැත්තන් මේ veriable එකෙන් වැඩක් ගන්ඩ බැ.

ඔය A a = new A(); කියල කරලා තියෙන්නේ A class එකෙන් object එකක් හදල තියන එක ඒක ගැන වැඩි විස්තර ඉදිරි post එකකින් කියන්නම්. දැන් පේනවා නේද මම කියපු දේ අපි instance variable එකක් විදිහට හදපු i සහ s main method එක ඇතුලේ access කරලා තියෙන්නේ හදපු object එකේ name එකෙන්(a.i සහ a.s) ඉතින් instance variable එකකකින් වැඩක් ගන්දනම් ඒ class එකෙන් object එකක් හදන්ඩම ඕනි.

හරි එහෙනම් අදට කියන්ඩ තියන ටික ඉවරයි ඓත් දවසක් java වල වැදගත් මාතෘකාවක් එක්ක එන්නම් අහ්හ්හ් අමතක කරන්ඩ එපා වැරදි තියනවනම් comment කරන්ඩ එහෙනම් ජය වේවා ......!!

Java Main Method

කාලෙක ඉදල හිතාගෙන ඉන්න වැඩක් වෙලාවක් හම්බුනා නිසා වැඩේ පටන් ගත්ත මේක මගේ 1 st blog post එක පට්ට චෝර වෙයි අව්ලක් නැ කියවල තියන අඩුපාඩු comment කරන්ඩකෝ.

එහෙනම් අපි වැඩේට බහිමු අද මම කියන්ඩ හදන්නේ මුලින්ම java ඉගන ගන්න අයට වැදගත් වන දෙයක් java programming language එකේ main method එක ගැන හැමෝම දන්නවා java කියන්නේ compiler language එකක් ඒ කියන්නේ අපි ලියන java code එක compiler එකක් එකක් හරහා තමයි machine language එකට convert වෙන්නේ. මේ process එක වෙනකොට අපි ලියපු code එකේ වැරදි තියනවනම් ඒවත් errors විදිහට පෙන්නනවා මේ විදිහට ඔක්කොම errors නැති උනාම අපිට පුළුවන් අපේ java code එක run කරන්ඩ code එක run කරනකොට JVM(java virtual machine) එක මුලින්ම හොයාගෙන යන්නේ main method එකට එකයි මේක මේ තරම් වැදගත්.

අපි හැමෝම දන්නවා java කියන්නේ object oriented programming language එකක් ඉතින් එක එක class එකට අදාල object හදන්නේ, අනිත් class වල තියන method call කරන්නේ මෙන්න මේ main method එක ඇතුලේ. තවත් සරලව කියනවනම් අපි උදාහරණයකට මොකක් හරි product එකක් හදන factory එකක් ගම්මු එකේ තියනවා main machine එකක් සහ තවත් පොඩි පොඩි machine ඉතින් මේ main machine එකෙන් කරන්නේ අර පොඩි පොඩි machine වලින් හදල දෙන ඒවා එකතු කරලා final output එක දෙන එක අන්න ඒ වැඩේම තමයි java වල main method එකෙනුත් කරන්නේ දැන්නම් කට්ටියට කලින්ට වඩා හොදටම තේරෙනවා ඇති කියල හිතෙනවා.

main method එකත් java වල normal method වගේම තමයි normal method ගැන මම ඊලග post වලින් කතා කරන්නම්කො දැනට මෙහෙම මතක තිය ගන්ඩකෝ. main method එකත් තියෙන්නේ java වල class එකක් ඇතුලෙම තමයි බලන්ඩකෝ මම පහලින් දාන්නම් මෙච්චර වෙලා කියපු එකේ structure එක එතකොට තවත් තේරුම්ගන්ඩ පුළුවන් වෙයි.

හරි දැන් අපි බලමු ම එකින් එකට තියන තේරුම් මොනවද කියල මම කලින් කිව්වනේ main method එකත් තියෙන්නේ class එකක් ඇතුලේ කියල අන්න ඒ class එක තමි ඔය class A කියල තියෙන්නේ .

main method එක වෙන්නේ ඉතුරු ටික තමයි දැන් බලමු මොකක්ද public කියන්නේ කියල public කියන්නේ access modifier එක එකෙන් තමයි method එකේ scope එක තීරණය කරන්නේ ඒ කිව්වේ ඒ method එක use කරන්ඩ පුළුවන් ඒක තියන class එක ඇතුලේ විතරද වෙනත් class වල ඉදලත් පුලුවන්ද කියන එක දැනට එහෙම මතක තිය ගන්ඩ පස්සේ access modifiers ගැන වෙනම post එකක් දාන්නම්කො.ඉතින් මේ main method එක JVM එකෙන් ඕනි තැනක ඉදල access කරන්ඩ පුළුවන් වෙනඩ ඕනි අන්න ඒ හේතුව නිසා තමයි අපි මෙතන public කියල දාල තියෙන්නේ.

දැන් බලමු static කියල දාන්නේ මොකද කියල අපිට මොකක් හරි method එකක් variable එකක් මුලින්ම Ram එකට load කරගන්ඩ ඕනි නම් තමයි අපි static key word එක use කරන්නේ ඉතින් මම කිව්වනේ හැම දෙයක්ම කරන්නේ main method එක ඇතුලේ කියල එහෙනම් ඉතින් ඔක්කොටම කලින් එක load වෙනඩ ඕනි කියල පොඩි ළමයෙකුටත් තේරෙනවනේ ඒ නිසා තමයි අපි static කියන එක ඔය දාල තියෙන්නේ.

factory එකක machine එකක් ගත්තම මොකක් හරි output එකක් එලියට එනවනේ ඒ වගේම තමි java වලත් method එකකින් ඇතුලේ process වෙලා මොකක් හරි data එකක් එලියට return කරනවා හැබැයි පෙළක් වෙලාවට මුකුත් return කරන්නේ නැති වෙලාවලුත් තියනවා ඉතින් ඔය void කියල දාල තියෙන්නේ එක තමයි main method එකෙන් අපි මුකුත් return කරන්නේ නැ එලියට ඇතුලේ ඉදන් call කරන එක තමයි කරන්නේ එහෙම මුකුත් return කරන්නේ නැති වෙලාවට java වල return type එකට දාන key word එක තමයි ඔය void කියන්නේ. මොකක් හරි return වෙන වෙලාවට දැන් ඒවා ගැන method ගැන කියල දෙනකොට කියන්නම්කො.

ඊළගට තියෙන්නේ main කියල ඕක තමයි method එකේ method name එක. ඒක main වෙනද ඔනිමි කියල නීතියක් නෑ නමුත් අපි java වල standard එකක් විදිහට main කියල use කරනවා.

ඊළගට තියෙන්නේ parameter list එක මේක ගැනනම් කිව්වට දැම්ම වැඩිය තේරෙන එකක් නැ එත් පොඩ්ඩක් කියන්නම්කො තව තව java ඉගන ගන්නකොට මේක ගැන තේරුම් යයි. factory එකක machine එකක් උනත් නිකම්ම output එකක් දෙන්නේ නැනේ එකට අවශ්‍ය අමුද්‍රව්‍ය අපි දෙන්ඩ ඕනි ඒ වගේම තමයි method එක ඇතුලේ මොනවා හරි දෙයක් කරගන්ඩ අපි data method එකට pass කරන්ඩ ඕනි එකට තමයි මේ parameter list එක අපි use කරන්නේ. main method එකේ තියන විශේෂත්වය තමයි අපි මේකට arguments pass කරන්නේ command line එක හරහා ඒ pass කරන හැම එකක්ම string array එකක් විදිහට තමයි ගන්නේ ඒක නිසා තමයි ඔය args කියන නමින් string array එකක් තියෙන්නේ එකේ name එකත් args වෙන්ඩම ඕනි නැ ඔන name එකක් දෙන්ඩ පුළුවන් නමුත් අර main method එකේ name එක main උන කතාව මෙතනටත් අදාලයි.

අන්තිමට තියෙන්නේ method body එක එක ඇතුලේ තමයි අපි කරන්ඩ ඕනි අනිත් හැම දේම කරන්නේ method call කරන ඒවා, object හදන ඒවා සියල්ලම වගේ.

තව පොඩි දෙයක් කියන්නම් හැබයි එක main method එකට අදාල නැ ඒ උනාට ඉස්සරහට දාන post වලට මේක නැතුවම බැරි වෙන නිසා මේක පොඩ්ඩක් කියන්නම්.method එකක් ඇතුලේ හරි කොහේ හරි අපි data manipulate කරලා ගන්න result එකක් java වලින් user ට බලාගන්ඩ පුළුවන් විදිහට print කරගන්නේ කොහොමද කියල තමයි දැන් කියන්ඩ යන්නේ. අපි result එක print කරගන්ඩ use කරන්නේ output stream එකක් එකට java වල use කරන්නේ system.out කියන stream එක එක කරන්නේ කොහොමද කියල පහල උදාහරණයකින්ම පෙනන්නම්කෝ.

මේ programme එකේ output එක වෙන්නේ screen එකේ Hellow world කියල print වෙන එක.

මම හිතනවා දැන් හැමෝටම main method එක ගැන හොද අවබෝදයක් ලැබෙන්ඩ ඇති කියල පලවෙනි post එක හින්ද හොදටම නැතුවත් ඇති තියන අඩුපාඩු මොනවද කියල කියන්ඩ ඊලග post වලදී හදාගෙන හොදටම මේ වැඩේ කරගෙන යන්ඩ එහෙනම් යාලුවනේ තවත් මෙවැනිම post එකකින් හමුවෙමු ජයවේවා..........!