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 එකකින් හමුවෙමු හැමෝටම ජය වේවා .....!!!!!