ජාවා තෙවන පාඩම

programming languages තවදුරටත්

අපි මුලින්ම කතා කරාෙන් High level language එකකින් ලියන program එකක් කියාවට නැංවීෙම්දී මුලින්ම එය Machine code එකට හැරෙවනවා කියලා

අපි ඒ ෙදයට කියනවා Translators කියලා
Translator’s වර්ග ෙදකක් තිෙයනවා
1. Compiler
2. Interpreter



Compiler
භාෂා පරිවර්තකෙයෝ වර්ග ෙදකක් ඉන්නවා. එක වර්ගයකට කලින් කතාව ලියලා දුන්නහම ඒ ෙගොල්ෙලෝ කතාෙව් වැරදි එෙහම තිෙයනවනම් ඒවා හදලා මුලු කතාවම ෙවනත් භාෂාවකට හරවනවා. කතාව කරන ෙකනාට තිෙයන්ෙන් පරිවර්තනය කරපු කතාව කියවන එකයි.

Compiler කියන වර්ගෙය්දී ඉස්ෙසල්ලාම එකකින් නිෙයෝග මාලාව ෙහවත් program එක ලියනවා. ෙම්කට අපි source code එක කියලා කියනවා.
ෙමහිදී සම්පූර්ණ program එකම Machine code එකට හැරෙවනවා

එහිදී program එෙක් ඇති සියලුම වැරදි ලැයිස්තුව අප ඉදිරිෙය් ෙපන්වනවා. ඒ වැරදි නිවැරදි කරලා ආෙයමත් compile කලහම Compile වූ program එක ලැෙබනවා. දැන් අර මුල් source code එක නැතිව වුවත් අපිට program එක කියාත්මක කරලා අවශ􀉕 ෙද් ලබාගන්න පුලුවන්.


Compiler
ඒත් යම් විදියකින් අපට අපි ලිව්ව program එෙක් යම් නිෙයෝගයක් ෙවනස් කිරීමට අවශ􀉕 නම් ඒක compile කල program එක පාවිච්චි කරලා කරන්න බැහැ. ආෙයත් අපට source code එක ගන්න ෙවනවා. ඒෙක් අවශ􀉕 ෙවනස්කම් කරලා ආෙයත් compile කරලයි ෙවනස් කරන ලද program එක පාවිච්චි කරන්න පුලුවන් ෙවන්ෙන්.
ඉස්සරනම් අපි යම් ආයතනයකට program එකක් ලිවීෙම්දි compile කල program එක ආයතනයට දීලා එක අපි ලඟ තියා ගන්නවා. ඒත් දැන් ෙලොකු ආයතන හුගාක් ෙවලාවට “programmer” ෙගන් source code එකත් ඉල්ලා ගන්නවා.

Compiler වලට උදාහරණ:-

Interpreters
හිතන්න භාෂා පරිවර්තනය කිරීෙම්දී බැරි ෙවලාවත් කතාව කරන ෙකනා ෙකොලයක් බලන්ෙන් නැතිව එෙව්ෙල් හිතලා කතා කරනවා කියල. එවැනි ෙවලාවක පරිවර්තකයාට මුළු කථාවම පරිවර්තනය කිරීමක් ගැන හිතන්නවත් බැහැ.ෙමොකද එෙහම මුළු කතාවම එෙවෙලම පරිවර්තනය කරන්න බැහැ. එතෙකොට කරන්න තිෙයන්ෙන් කථිකයා කතාකරන ෙප්ලිෙයන් ෙප්ලිය පරිවර්තකයා විසින් අවශ􀉕 අෙනක් භාෂාවට පරිවර්තනය කිරීමයි. ෙම් වැෙඩ්දී වැරදී අහුෙවන්ෙන් ඒ ඒ ෙප්ලිය කතා කරනෙකොටයි. ඒ කියන්ෙන් ඒ ෙප්ලියට ආවහමයි.

ෙම් වෙග්මයි Interpreters එකත් පවිච්චි කරල High level language එකකින් ලිව්ව program එකක් Machine code එකට හැරවීෙම්දී ෙවන්ෙනත්.
ඇත්තටම compiler එෙක් වෙග් විෙශේෂෙයන් එෙහම Translate කිරීමක් කරන්න අපිට සිද්ද ෙවන්ෙන් නැහැ. අපි High level language එකකින් program එක ලියලා ඒක කියාත්මක කරනවිට ෙප්ලිෙයන් ෙප්ලියයි Interpreter එක මගින් Machine code එකට හැරෙවන්ෙන්.
ඊලඟට ඒ හැරවුනු ෙප්ලිය කියාවට කියාවට නැෙගනවා. ෙමතනදී යම් ෙප්ලියක වරදක් තිෙයනවනම් ඒ ෙප්ලියට ආවහම තමයි ඒ වැරැද්ද ෙපෙනෙන්. ඒ වැරැද්ද නිවැරදි කරලා ආෙයත් program එක කියාත්මක කළහම ඊළඟ ෙප්ලිෙය් තවත් වැරැද්දක් තිෙයනවනම් ඒ වැරැද්ද ෙපන්වනවා
කාෙලකට ඉස්ෙසල්ලා භාවිතෙය් තිබූ “GW BASIC” කියන Language එක Interpreters වලට ෙහොද උදාහරණයක්.

Compiler & Interpreters
දැන් ඔබට ෙත්ෙරනවා ඇති Compiler එකකින් Translate කරද්දි ඒ වැෙඩ් කරන්න ඕන එක පාරක් විතරක් හන්දා කලායින් පස්ෙසේ අපට ඕෙන් වාර ගණනක් Compile කල program එක කියාත්මක කරන්න පුලුවන්කියලා. ඒ නිසා ෙම් කමය වඩා ෙව්ගවත් ෙවනවා.
ඒත් Interpreter එකකින් කරද්දී අපි program එක කියාත්මක කරන වාරයක් වාරයක් ගනෙන් Interpreter ෙවන නිසා ෙම් විදිය ටිකක් ෙවලා යනවා.
අද කාෙල් භාවිතා ෙවන වඩා දියුනු නවීන low level languages වල

(Visual Basic, Java) ෙම් ලක්ෂණ ෙදකම තිෙයනවා.

Share this

Related Posts

Previous
Next Post »