joinlanka

joinlanka

Advertise here : Rs.500/= per week (email: admin@kuppiya.lk)

ක්‍රමලේඛන භාෂා වැඩ කරන්නේ කොහොමද??

Discussion in 'ක්‍රමලේඛන-programming' ආරම්භ කරන ලද්දේ ටෙකා, Sep 12, 2015.

  1. Madhawa Habarakada
    Offline

    Madhawa Habarakada Moderator Staff Member VERIFIED

    Joined:
    May 2, 2015
    අදහස්:
    1,963
    Likes Received:
    3,079
    :D :D :D

     
  2. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    මොකක්ද මේ matrix කියන්නේ

    චුටක් තේරුම් කරන්නකෝ
    මේ මොකක්ද මේකේ කියලා තියෙන්නේ

    කොහොමද මේක වෙන්නේ

     
  3. chamiya
    Offline

    chamiya Moderator Staff Member VERIFIED

    Joined:
    Apr 5, 2014
    අදහස්:
    1,593
    Likes Received:
    1,137
    At the basic level, all the computer ever deals with are 0 and 1. Every bit of memory the CPU examines, 0s and 1s. Every instruction the CPU receives, 0s and 1s. Every input, every interrupt, everything -- 0s and 1s.

    In the earliest computers, input was by literal switches. Users flicked the switches into the correct positions (eight at a time -- a single byte) and used a button to order the computer to take that as its next value. A single mistake, power flicker, or other problem meant starting over, a painstaking and frustrating process. You can imagine why we've since developed better methods.

    In all computers, from the earliest to the most modern, the CPU is just set of electronic circuits. Incredibly complex in implementation, but simple in reality. A CPU does the following, at the lowest level:
    1. Retrieve the value in memory located at the address specified by the Instruction Pointer (IP) register.
    2. Interpret that value as an instruction.
    3. Execute that instruction.
    4. Increase the Instruction Pointer.
    5. Return to Step #1.

    Instructions can be things like "LOAD (memory address) INTO (register number)" or "MULTIPLY (register A), (register B), STORE IN (register C)". More complex instruction sets might use "MULTIPLY FROM (memory address A1) TO (memory A2) BY (memory B1) TO (memory B2) STORE IN (memory C1) TO (memory C2)". Of course, this is just a series of 0s and 1s, as far as the CPU is concerned. The exact circuitry knows how to reroute electrical signals based on these instruction values. For more information, take a Computer Logic Design course at your local university.

    In modern computers, a low-level operating system handles basic operations, such as starting up the computer, checking all the components (the Power-On Self-Test, or POST), and so forth. This piece of software is called the BIOS. The BIOS allows you to "boot" to "bootable media", which basically means "read the software off of this device -- floppy disk, CD-rom, DVD-rom, USB key, hard disk, etc -- and start that program. This is how you load Windows, Linux, OSX, or any other operating system.

    Characters that you can read, like A, B, C, 1, 2, 3, !, @, #, are all just interpretations of underlying binary. There are a lot of schemes for how you map (binary value) to (character(s) to display). The simplest and most common is ASCII, which maps single-byte values onto characters. For example, capital a (A) is 65 (or 0x0100 0001), while lower-case a (a) is 97 (or 0x0110 0001). You can find more of these values at http://asciitable.com/ . Other common "encodings" include UTF-8, UTF-16, and a few others. Some of these allow you to encode more than 255 characters, which is very useful for Japanese, Chinese, and all sorts of other human languages.

    These are just a few of the dozens of layers of "abstraction" built on the actual machine hardware to make our lives as programmers and computer users simpler. If you want to learn more, I strongly suggest that you sit in on the Computer Science lectures at your local university, because they will go into a lot more detail than I can manage here. Computer Science is a surprisingly deep field, given the fact that it's barely 60 years old.

    Source

     
    Gihan සහ ටෙකා මෙම අදහසට කැමතියි.
  4. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    එලම අයියා තැන්ක්ස් සිංහලෙන් ප්ලීස්

     
  5. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    thawa kawruth nadda sinhalen danna kenek

     
  6. nishurox
    Offline

    nishurox ක්‍රියාකාරී සාමාජික

    Joined:
    Jun 7, 2015
    අදහස්:
    311
    Likes Received:
    255
    eka aththa math eka ahala thiyenawa api type karana hema akurakatama binary code ekath thiyenawa

     
    ටෙකා මෙම අදහසට කැමතියි.
  7. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    @chamiya dan online innawa dakka sinhalen pahadili kirimak one

     
  8. Samanha
    Offline

    Samanha ප්‍රකට සාමාජික VERIFIED

    Joined:
    Aug 11, 2015
    අදහස්:
    361
    Likes Received:
    365

    ඔයා අහන්නේ ලොකු සංකීර්න දෙයක් ඔය ගැන ටිකක් ඉක්මනට තෙරුම් කරන්න අමරුයි යලුවා.. ඔයා දන්නවද අපි පාවිචි කරන Motherboard වල North and South කියලා චිප් දෙකක් තියනනවා ඔය කියන ක්‍රියාවලිය මෙහෙය වන්නේ ඒ චිප් 2 න් තමා. මොකද processors සදහා විදාන දෙන්නේ ඔය North චිප් එකෙන්.
    අපි උදා: ගත්තොත් ඔයා කී බෝඩ් එකේ එක බටන් එකක් ඔබන වානම් ඒ සිග්නල්එක කෙලින්ම processors දුන්නට දන්නෑ සිග්න්ල් එකක් ආවද කියලාවත් මොකද processors ඉතා වෙගයෙන් වැඩ කරන නිසා ඒක නිසා ඔය North චිප් එකෙන් කරන්නේ අපි දෙන විදානේ processors වෙගයට වැඩි
    කරන එක ඉන් පසු නැවත් ඔය විදානය කෙලින්ම monitor දුන්නට අපට මුකුත් පේන්නෑ මොකද monitor එතරම් වෙගවත් නෑ එකනිසා ඒ සිග්නල් එක නැවත අඩුකරලා දෙන්න ඔනේ. South චිප් එකෙන් කරන්නේ නැවත් අර වැඩි කරපු සිග්නල් එක අඩු කරලා monitor දෙන එක එතකොට අපිට monitor රුපයක් පෙනවා අනේ මන්දා මෙවා මං කියන විදියට ඔයාලට තේරෙයිද කියලා. මං දන්න විදියට තමා කිව්වේ.


     
    Pahasara Ridmaka සහ ටෙකා මෙම අදහසට කැමතියි.
  9. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    awlak naa kiwa eka theruna mata one kohomada meka wenne kiuyana eka kohomada api gahana akuru ilakkam 10 wenne

     
  10. Samanha
    Offline

    Samanha ප්‍රකට සාමාජික VERIFIED

    Joined:
    Aug 11, 2015
    අදහස්:
    361
    Likes Received:
    365
    එක වෙන්නේ Motherboard වල තියන චිප් මගින්. ඒ වායේ program තියනවා උදා: bios chip ගැන දන්නවානේ එවගේ. ඕක වෙන්නේ ගෙට් වලින් ඔයා ගෙට් වර්ග දන්නවනම් ඕක තෙරුම් ගන්න පුළුවන්.
    PLC Programming වලින් තමා මත් ඕක හරියට දැන ගත්තේ

     
    Last edited: Sep 23, 2015
    ටෙකා මෙම අදහසට කැමතියි.
  11. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    ගේට්ස් ගැන දන්නේ නම් නෑ දන්නේ 11දි උගන්නන ඒවා විතරයි

     
  12. Samanha
    Offline

    Samanha ප්‍රකට සාමාජික VERIFIED

    Joined:
    Aug 11, 2015
    අදහස්:
    361
    Likes Received:
    365
    ඒකනේ යාලුවා ඔය වැඩේ හරියට දැනගන්න ගේට් ගැන ඉගනගන්න. වෙනවා.

     
  13. Bottle Buddy
    Offline

    Bottle Buddy විශිෂ්ට සාමාජික

    Joined:
    Apr 26, 2015
    අදහස්:
    1,087
    Likes Received:
    742
    Mamanam oya film ekata echchara asa naha.

     
    ටෙකා මෙම අදහසට කැමතියි.
  14. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
  15. nishurox
    Offline

    nishurox ක්‍රියාකාරී සාමාජික

    Joined:
    Jun 7, 2015
    අදහස්:
    311
    Likes Received:
    255
    mma danna widiyata dn symbol ehemath yofa gannawa oowata

     
    ටෙකා මෙම අදහසට කැමතියි.
  16. 0xEDD1E
    Offline

    0xEDD1E ප්‍රකට සාමාජික contributor - VIP

    Joined:
    Apr 14, 2016
    අදහස්:
    429
    Likes Received:
    687
    ක්‍රමලේඛන භාෂා වැඩ කරන්නේ කොහොමද? කියන එකෙන් ටෙකා අදහස් කරන්නේ compilers වැඩ කරන්නේ​
    කොහොමද කියන එක වෙන්න ඇති, මොකද ක්‍රමලේඛන භාෂාවක් කිසිම වැඩක් කරන්නේ නෑ. ඇත්තටම ක්‍රමලේඛන භාෂාවක් කියන්නේ අපිට software එකක් ලියන්න හදාගත්තු රීති පද්ධතියක් වගේ. අපි ඒ රීති පද්ධතියට අනුව අපේ අවශ්‍යතාවය (ඒ කියන්නේ අපිට මොන වගේ දෙයක්ද වෙන්න ඕන කියන එක) අපිට තේරුම් ගන්න පුළුවන් විදිහකට (ඉංග්‍රීසි වචන යොදා ගෙන) ඉදිරිපත් කරනවා.

    මෙහෙම කිව්වම ඕනේ කෙනෙක්ට ඔළුවට එන ප්‍රශ්නේ තමයි (ටෙකාගේ මේ ප්‍රශ්නෙටත් හේතුව ඒක වෙන්න ඇති) ​
    "ඇයි කෙලින්ම අපිට ඉංග්‍රීසි හරි සිංහල හරි වගේ අපිට හොඳටම තේරෙන භාෂාවක් පාවිච්චි නොකරන්නේ?", එහෙම ස්වභාවික භාෂාවක් යොදා නොගන්න හොඳ හේතුවක් තියෙනවා. ඒ තමයි ස්වභාවික භාෂා වල තියෙන උභයාර්ථ ස්වභාවය (ambiguity), ඒ කියන්නේ "යම් අදහසක් පල කරන්න ක්‍රම කිහිපයක් තිබීම" කියලා බොහොම සරලව කියන්න පුළුවන්.
    උදාහරණයක් විදිහට මේ ඉංග්‍රීසි වාක්‍ය ගන්න Foreigners are hunting dog, මේ වාක්‍යයේ තේරුම මොකක් වෙන්න පුළුවන්ද මට නම් මෙතන අදහස් 2ක් හිතාගන්න පුළුවන්.
    • විදේශිකයෝ දඩයම් බල්ලෝය.
    • විදේශිකයෝ බල්ලෝ දඩයම් කරති.
    ඉතින් මේ දෙකෙන් මොකද්ද හරි එක. එක අපිට තීරණය කරන්න වෙන්නේ ඒ කතාවට අදාල සන්දර්භය සලකලයි. ඒ කියන්නේ අපි ඒවෙලාවේ විදේශිකයන්ට බැන බැන හිටියනම් අපි ගන්න ඕන පලවෙනි තේරුම්, එහෙම නැත්නම් කවුරු හරි ඇහුවනම් විදේශිකයෝ මොනවද කරන්නේ කියලා අපි ගන්නේ ඕනේ දෙවෙනි තේරුම.
    මිනිස්සුන්ටනම් බොහොම ලේසියෙන් මේ වගේ පැටලවිලි ලිහා ගන්න පුළුවන්. ඒත් පරිගණකය බොහොම මෝඩයි, එයට මේ වගේ දෙයක් හරියට තේරුම් ගන්න බෑ. ඉතින් අපි ඉංග්‍රීසි හරි සිංහල හරි පාවිච්චි කරාල programming කළා නම් මේ වගේ තැන වලදී පරිගණකය සහ අපි දෙගොල්ලොම ලොකු අමාරුවක වැටෙනවා.
    ඒ හින්ද මේ වගේ උභයාර්ථ මගහරින්නම් අපිට යම් පැහැදිලි රීති පද්ධතියක් අවශ්‍ය වෙනවා. ඒ රීති පද්ධතිය තුලදී අපිට යම් අදහසක් පලකරන්න තියෙන්නේ එකම එක ක්‍රමයක් විය යුතුමයි. ඒ විදිහට හුඟක් සැලසුම් කරලා හඳපු රීති පද්ධතියකට තමයි අපි ක්‍රමලේඛ භාෂාවක් කියලා කියන්නේ.

    ඇත්තටම මෙතන software එක machine language එකට convert කරනවා කියන්නේ අපි මුලින් රීති පද්ධතියක් (ක්‍රමලේඛ ​
    භාෂාවක්) භාවිතා කරලා ඉදිරිපත් කරපු අදහස් සමුදාය පරිගණකයට දැනෙන 1 0 (ද්වීමය) භාෂාවට පරිවර්තනය කරන එකයි.
    මේ පරිවර්තනය කරන්නට compiler/interpreter එක ඊට අදාල ක්‍රමලේඛ භාෂාවේ ඇති අංග 3 ක් යොදා ගන්නවා.
    ඒ තමයි,
    • syntax
    • static semantics
    • semantics
    මේ දේවල් එකින් එක විස්තර කලානම් හොඳයි කියලා හිතනවා.

    [1] Syntax
    syntax කියලා හඳුන්වන්නේ භාෂාවකින් නිවැරදි ව්‍යාකරණ සහිතව program එකක් ලබාදෙන ලෙස සංකේත (symbols) එකතු කල හැකි ක්‍රම වලටයි.
    උදාහරණයක් ගනිමු . C භාෂාවේදී අපිට මේ විදියට යම් ගණිත ප්‍රකාශනයක් දක්වන්න පුළුවන්.
    Code:
     x = y * 3 + z 

    මේ code එකෙන් නිවැරදිව අපිට ඕන කරන x = 3y + z කියන සමීකරණය නිරූපණය වෙනවා.
    එත් මේක බලන්න.
    Code:
    x = y * + 3 z
    මොකද්ද මේකේ තේරුම C වලදී නම් මේකට කිසිම තේරුමක් නෑ. ඒනිසා එක වැරදි අදහසක්. මේ වගේ දෙයක් compiler එකට හමුවුනොත් එක error message එකක් විදිහට දක්වනවා.
    මෙන්න මේ නිවැරදි ව්‍යාකරණය ලැබෙන විදිහට x, y, z, + , =, * කියන සංකේත පෙළගස්වන්න පුළුවන් ක්‍රමයට( x = y * 3 + z) තමයි syntax ලෙස හැඳින්වෙන්නේ.
    [2] Static Semantics
    static semantics ලෙස හැඳින්වෙන්නේ ඒ ඒ අදාල ක්‍රමලේඛ භාෂාවේ පවතින රීති පද්ධතියයි. වඩාත් නිවැරදිවම කිව්වොත් static semantics ලෙස හැඳින්වෙන්නේ ඒ භාෂාවේ ආකෘතිය රැකගැනීමට යොදා ගෙන තියෙන සීමා කිරීම් (restrictions).
    උදාහරණයක් අරගෙන පැහැදිලි කලොත් මෙන්න මෙහෙමයි,
    මෙන්න මේ C code එක සලකන්න.
    Code:
    int x = 0;
    y = x  + 123;
    මෙතැන වැරැද්දක් ඇති බව C දන්නා කෙනෙක්ට තේරෙනවා ඇති. ඒ තමයි y කියන variable එක declare කරලා නොමැති වීම( C වලදී variable එකක් භාවිතා කරන්න කලින් එක හඳුන්වාදෙන්න ඕනේ: statically types programming languages). මෙතන syntax වල කිසිම වරදක් නැ එත් මෙතැන් තියෙන වැරැද්ද තියෙන්නේ C භාෂාවේ මුලික නීති රීති වලට අනුකුල නොවීමයි. ඒනිසා මෙතනදීත් compiler එක error message එක දක්වල compilation එක නවත්වනවා.
    හැබැයි මේ python code එක බලන්න,
    Code:
    x = 0
    y = x + 123
    python interpreter එකට අනුව මෙතන කිසිම ප්‍රශ්නයක් නෑ. මොකද python වලදී C වල වගේ variables කලින් declare කරන්න වුවමනාවක් නෑ. (එකට කියනව dynamically typed programming languages කියලා)​
    [3] Semantics
    Semantics කියලා හඳුන්වන්නේ ඒ program එකේ අදහසයි.
    පෙර සඳහන් කල
    Code:
    x = 0
    y = x + 123
    code එක සලකන්න. මේකේ semantic එක, අදහස තමයි,
    Code:
    x 0ට සමාන කරන්න.
    x ට 123 ක් එකතු කර y ට සමාන කරන්න.
    
    මෙන්න මේ තේරුම තමයි අවසානයේදී compiler/interpreter එක හරහා machine code එකක් බවට හැරවෙන්නේ. හැබයි හුඟක් compilers අපේ source code එක කෙලින්ම machine code එකට හරවන්නේ නෑ.
    ඒවා කරන්නේ අපේ source code එක assembly language එකට හරවන එකයි, එතනින් එහාට assembler කියලා තවත් program එකක් භාවිතා කරලා තමයි machine code එක ලබා ගන්නේ.
    මෙන්න මේ කුඩා C program එක සලකන්න.
    Code:
    int main(void)
    {
        int Y, X;
        Y = 3;
        X = (Y + 3) * 4;
    
        return 0;
    }
    මේක assembly language එකට පරිවර්තනය කලාම ලැබෙන්නේ මෙන්න මෙහෙම output එකක්.

    Code:
        .file    "add.c"
        .def    ___main;    .scl    2;    .type    32;    .endef
        .text
        .globl    _main
        .def    _main;    .scl    2;    .type    32;    .endef
    _main:
    LFB0:
        .cfi_startproc
        pushl    %ebp
        .cfi_def_cfa_offset 8
        .cfi_offset 5, -8
        movl    %esp, %ebp
        .cfi_def_cfa_register 5
        andl    $-16, %esp
        subl    $16, %esp
        call    ___main
        movl    $3, 12(%esp)
        movl    12(%esp), %eax
        addl    $3, %eax
        sall    $2, %eax
        movl    %eax, 8(%esp)
        movl    $0, %eax
        leave
        .cfi_restore 5
        .cfi_def_cfa 4, 4
        ret
        .cfi_endproc
    LFE0:
        .ident    "GCC: (GNU) 4.9.3"
    
    මෙතනින් පස්සේ assembler එක මේ code එක machine language එකට හරවනවා.
    මේ code එකේ වම් පැත්තේ දක්වල තියෙන්නේ assembly code එකට අදාල machine code එකයි.
    Code:
       1                      .file    "add.c"
       3                      .text
       4                      .globl    _main
       6                  _main:
       7                  LFB0:
       8                      .cfi_startproc
       9 0000 55               pushl    %ebp
      10                      .cfi_def_cfa_offset 8
      11                      .cfi_offset 5, -8
      12 0001 89E5             movl    %esp, %ebp
      13                      .cfi_def_cfa_register 5
      14 0003 83E4F0           andl    $-16, %esp
      15 0006 83EC10           subl    $16, %esp
      16 0009 E8000000         call    ___main
      16      00
      17 000e C744240C         movl    $3, 12(%esp)
      17      03000000
      18 0016 8B44240C         movl    12(%esp), %eax
      19 001a 83C003           addl    $3, %eax
      20 001d C1E002           sall    $2, %eax
      21 0020 89442408         movl    %eax, 8(%esp)
      22 0024 B8000000         movl    $0, %eax
      22      00
      23 0029 C9               leave
      24                      .cfi_restore 5
      25                      .cfi_def_cfa 4, 4
      26 002a C3               ret
      27                      .cfi_endproc
      28                  LFE0:
      29 002b 90               .ident    "GCC: (GNU) 4.9.3"
    
    මීටත් පස්සේ linkers/loaders කියලා තවත් program එකකින් අපේ code එකට පිටින් ඇතුලත් වෙන්න ඕන codes (printf() වගේ දේවල්) එකතු කරලා සම්පුර්ණ program එක අපිට ලබාදෙනවා. (විශේෂයෙන් කියන්න ඕන මේ assembler output එක machine dependent එකක්, ඒ කියන්නේ windows වලදී generate කරපු machine code එකක් Linux වලදී වැඩ කරන්නේ නෑ)

    මම මේ පෙන්නලා තියෙන්නේ C program එකක් compile වෙන විදිහයි. අනිත් ක්‍රමලේඛ භාෂාත් මේ විදිහම තමයි. ඒ වුනාට යම් යම් වෙනස්කම් පවතිනවා. උදාහරණයක් විදිහට python, Java වගේ VM එකක් පාවිච්චි කරන භාෂා මීට වැඩිය චුට්ටක් වෙනස්. Java වගේ භාෂාවක source code එකක් කොහොමටවත් machine code එකට පරිවර්තනය වෙන්නේ නෑ. ඇත්තටම javac compiler එකෙන් කරන්නේ .java file එකක් bytecode කියලා හඳුන්වන විශේෂ assembly වගේ code එකකට හරවන එකයි. මේ bytecode එක අපේ computer එක කෙලින්ම ක්‍රියාත්මක කරන්නේ නෑ, එක ක්‍රියාත්මක කරන්නේ java VM එක මගිනුයි. VM(virtual machine) එකක් කියන්නේ සත්‍ය පරිගණකයක් වගේ ක්‍රියාත්මක වෙන අතත්‍ය පරිගණකයක්(මේකත් තවත් software එකක්). මෙන්න මේ virtual machine එක නිසා තමයි java programs platform independent වෙන්නේ. මොකද VM එකක් තියෙන ඕනෙම පරිගනකයක java bytecode එක run කරන්න පුළුවන් නිසා. python වැඩ කරන්නෙත් මේ විදිහටමයි (හැබයි bytecode එකක් පෙනෙන්න ලැබෙන්නේ නැ). මෙන්න මෙහෙම තමයි මට තේරෙන විදිහට ක්‍රමලේඛ භාෂාවක් වැඩ කරන්නේ, මට මොනවත් මගහැරිලා/අපැහැදිලි දෙයක් තිබුනොත් අහන්න. තවත් මේ ගැන කියවන්න ඕනේ අයට මුලාශ්‍ර යටතේ තියෙන links වලට ගිහින් කියවන්න පුළුවන්.

    මුලාශ්‍ර
    [1] https://en.wikipedia.org/wiki/Programming_language
    [2] Generating mixed source and assembly list using GCC
    [3] https://en.wikipedia.org/wiki/Java_(programming_language)
    [4] How exactly does java compilation take place? - stackoverflow post
    [5] How compilers work?

     
    Shanilka Wariyapperuma, Bottle Buddy, ටෙකා සහ 1 වෙනත් අය මෙම අදහසට කැමතියි.
  17. 0xEDD1E
    Offline

    0xEDD1E ප්‍රකට සාමාජික contributor - VIP

    Joined:
    Apr 14, 2016
    අදහස්:
    429
    Likes Received:
    687
    කලින් දාපු post එකේ මට කියන්න අමතක වෙච්චි දෙයක තියෙනවා.
    ටෙකා අහල තිබුනනේ කොහොමද අපි ලියන වචන 1 0 විදිහට හරවන්නේ කියලා. එකට උත්තරේ තමයි (මම කලින් post එකේ අන්තිමට දාපු code ලිස්ටින්ග් එක බැලුවොත් තේරේවි) හැම assembly instruction එකකටම අදාල binary codes එකක් තියෙනවා, එකට කියන්නේ OP Codes කියලා
    උදාහරණයක් විදිහට මේ line එක බලන්න
    Code:
    000e C744240C         movl    $3, 12(%esp)
    මෙතන hex වලින් තියෙන්නේ (000E C744240C) ඒ අදාල OP code එකයි. assembler එක මේ OP Codes දන්නවා (මේ OP Code ගණිත ක්‍රමයකින් ගන්න පුළුවන්, Intel Software Developer Manual කියෙව්වොත් ඒ ගැන දැනගන්න පුළුවන්: ඒ පොත පිටු 4000 ක් පොතක්:eek:). ඒනිසා assembler එකට කරන්න තියෙන්නේ ඒ අදාල instruction එකට අදාල OP Code එක (අනිවාර්යයෙන්ම එක OP Code එකයි තියෙන්නේ) ගැලපෙන ක්‍රමයකට output file එකට ලියන එකයි.

    compilers/interpreter ගැන ගිහාන්ගේ post එකත් කියෙව්ව්වොත් උද post එකට තවත් හොඳයි

     
    Last edited: Apr 17, 2016
    Bottle Buddy, ටෙකා සහ මිහිසර මෙම අදහසට කැමතියි.
  18. මිහිසර
    Offline

    මිහිසර founder CEO Staff Member

    Joined:
    Apr 5, 2014
    අදහස්:
    7,380
    Likes Received:
    8,213
    ස්තුතියි සහෝ
    @ටෙකා
    දැන් ඉතින් වැඩේ හරි නේද

     
    ටෙකා මෙම අදහසට කැමතියි.
  19. Gihan_Cxo
    Offline

    Gihan_Cxo ප්‍රකට සාමාජික

    Joined:
    May 25, 2015
    අදහස්:
    821
    Likes Received:
    782
    ටෙකාට දැන සැනසීමේ නින්ද යයි:Motherofgod::Score!:

     
    ටෙකා සහ මිහිසර මෙම අදහසට කැමතියි.
  20. ටෙකා
    Offline

    ටෙකා විශිෂ්ට සාමාජික VERIFIED

    Joined:
    May 15, 2015
    අදහස්:
    2,267
    Likes Received:
    1,938
    හම්ම තැනක් යූ තාක් යූ ගොඩාක්
    හරි අයියේ මෙහෙම පැහැදිලි කරනකොට ඉතින් කියලා වැඩක් නා නියමයි

    හෙහෙ ඔවොව්

    @0xEDD1E ගොඩාක් ස්තුතියි මේ ලිපියට

    එත් මට තාම තේරෙන්නේ නැත්තේ අපි මෙහෙම අකුරෙන් ගහන ඒවා කොහොමද 1 0 වෙන්නේ කියන එක එතකොට තව කොහොමද c c++ වගේ භාෂා හැදුනේ කියන එක
    ඒවගේම තමා මේ 1 0 කියන්නේ කරත එක තියෙනවා නා කියන එකනේ ඉතින් කොහොමද අකුරකින් එක පෙන්නන්නේ කොහොඅද අපි හදන සොෆ්ට්වෙයා කරත එක තියෙනවා කරන්ට් එක නා කියන තැනට එන්නේ

     
    මිහිසර මෙම අදහසට කැමතියි.




Loading...

Share This Page