റൈറ്റിംഗ് ഒഎസ് ബൂട്ട് ലോഡറുകൾ, ഡ്രൈവറുകൾ, മെമ്മറി ഏരിയകൾ റീറൈറ്റിംഗ്, ഒരു കമ്പ്യൂട്ടറിൽ പ്രവർത്തിക്കുന്നതിനുള്ള മറ്റ് ജോലികൾ എന്നിവ അസംബ്ലർ ഉപയോഗിച്ച് നടപ്പിലാക്കുന്നു. അസംബ്ലി ഭാഷയെക്കുറിച്ചുള്ള തിരഞ്ഞെടുത്ത പുസ്തകങ്ങൾ ഒരു മെഷീൻ അധിഷ്ഠിത ഭാഷയുടെ പ്രവർത്തന തത്വം മനസ്സിലാക്കാനും അതിൽ പ്രാവീണ്യം നേടാനും നിങ്ങളെ സഹായിക്കും.

1. Revich Yu. - അസംബ്ലി ഭാഷയിൽ Atmel AVR മൈക്രോകൺട്രോളറുകളുടെ പ്രായോഗിക പ്രോഗ്രാമിംഗ്, 2014.

മൈക്രോകൺട്രോളർ പ്രോഗ്രാമിംഗ് മേഖലയിൽ "പുതിയ രക്തം". Atmel AVR-ന്റെ സവിശേഷതകൾ വിശദമായി വിവരിച്ചിരിക്കുന്നു, കമാൻഡുകളുടെയും റെഡിമെയ്ഡ് പാചകക്കുറിപ്പുകളുടെയും ഒരു ലിസ്റ്റ് ഉണ്ട് - ഉദാഹരണങ്ങളുള്ള അസംബ്ലർ. ഒരു നല്ല കാര്യംറേഡിയോ അമച്വർമാർക്കും എഞ്ചിനീയർമാർക്കും, പുതിയ കോഡർമാർക്കും ഇത് അനുയോജ്യമാണെങ്കിലും: AVR MK യുടെ ചരിത്രം, കുടുംബങ്ങൾ, കഴിവുകൾ എന്നിവ സ്പർശിക്കുന്നു. ആമുഖം ലാക്കോണിക് ആണെന്നും പെട്ടെന്ന് പോയിന്റ് നേടുന്നുവെന്നും ശ്രദ്ധിക്കേണ്ടതാണ്, അതിനാൽ വരികളെക്കുറിച്ച് പരാതിപ്പെടേണ്ടതില്ല.

2. കലാഷ്നിക്കോവ് ഒ. - അസംബ്ലി ഭാഷ ലളിതമാണ്. പ്രോഗ്രാമിലേക്ക് പഠിക്കുന്നു, 2011

ഇപ്പോഴും അടിസ്ഥാന പദങ്ങൾ ഗൂഗിൾ ചെയ്യുകയും അസംബ്ലി പാഠപുസ്തകത്തിനായി തിരയുകയും ചെയ്യുന്ന തുടക്കക്കാർക്ക് ഒരു യഥാർത്ഥ ട്രീറ്റ്. ഇത് അവനാണ്. ഭാഷയും ആദ്യ പ്രോഗ്രാമുകളും സ്വയം പരിചയപ്പെടുന്നതിനു പുറമേ, വേദന പോയിന്റുകളും സ്പർശിക്കുന്നു - തടസ്സങ്ങൾ: ഒരു ലളിതമായ കാര്യം, എന്നാൽ ആദ്യം മനസ്സിലാക്കാൻ പ്രയാസമാണ്. ഓരോ അധ്യായത്തിലും, അസംബ്ലർ പാഠങ്ങൾ കൂടുതൽ സങ്കീർണ്ണമാകും, അവസാനം വായനക്കാരന് അസംബ്ലറിൽ പ്രോഗ്രാമുകൾ എഴുതാനും അവ ഒപ്റ്റിമൈസ് ചെയ്യാനും വൈറസുകൾ, ആന്റിവൈറസുകൾ, മെമ്മറി, ഫയൽ സിസ്റ്റങ്ങൾ എന്നിവയിൽ പ്രവർത്തിക്കാനും കഴിയും.

3. Ablyazov R. - x86-64 പ്ലാറ്റ്‌ഫോമിൽ അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗ്, 2011

സംരക്ഷിത മോഡിലും ലോംഗ് മോഡിലും പ്രോസസർ പ്രവർത്തനത്തിന് ഊന്നൽ നൽകുന്നു. Win32, Win64 എന്നിവയിലെ പ്രോഗ്രാമിംഗിന് ഇത് ഒഴിച്ചുകൂടാനാവാത്ത അടിസ്ഥാനമാണ്, ഇത് മോഡ് വ്യത്യാസങ്ങൾ കണക്കിലെടുത്ത് അസംബ്ലർ കമാൻഡുകൾ, തടസ്സങ്ങൾ, വിവർത്തനം, സംരക്ഷണ സംവിധാനങ്ങൾ എന്നിവയെ ബാധിക്കുന്നു. വികസനം പരിഗണിക്കുന്നത് ജാലകങ്ങളുള്ള ആപ്ലിക്കേഷനുകൾഡ്രൈവർമാരും. ഈ അസംബ്ലർതുടക്കക്കാരായ കോഡർമാർക്കും അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിലേക്ക് ഉടനടി മാറിയവർക്കും പാഠപുസ്തകം അനുയോജ്യമാണ്, എന്നാൽ x86-64 ഹാർഡ്‌വെയർ പ്ലാറ്റ്‌ഫോമിനെക്കുറിച്ച് കാര്യമായ ധാരണയില്ല.

4. Stolyarov A. - Unix OS-ന് വേണ്ടി NASM അസംബ്ലി ഭാഷയിൽ പ്രോഗ്രാമിംഗ്, 2011.

ടെർമിനോളജി മുതൽ ഒഎസുമായുള്ള ഇടപെടൽ വരെ, ഇത് അതിശയോക്തി കൂടാതെ, മികച്ച ഒന്നാണ് അധ്യാപന സഹായങ്ങൾ. അസംബ്ലി പ്രോഗ്രാമിംഗ് പഠിക്കാൻ ആഗ്രഹിക്കുന്നവർക്ക് പുസ്തക ഷെൽഫുകൾ ഓവർലോഡ് ചെയ്യാൻ ആഗ്രഹിക്കാത്തവർക്ക് ഈ പാഠപുസ്തകം മതി. NASM അസംബ്ലി ഭാഷയുടെ വാക്യഘടന വിശദമായി വിവരിച്ചിരിക്കുന്നു, രജിസ്റ്ററുകളും മെമ്മറിയും, വ്യത്യസ്ത സങ്കീർണ്ണതയുടെ പ്രവർത്തനങ്ങൾ, കമാൻഡുകൾ സ്പർശിച്ചു, കൂടാതെ ഉദാഹരണങ്ങളും നൽകിയിരിക്കുന്നു.

മനുഷ്യ കമാൻഡുകൾ നടപ്പിലാക്കാൻ ഒരു യന്ത്രത്തിന് വേണ്ടി ഹാർഡ്‌വെയർ ലെവൽ, "പൂജ്യം, ഒന്ന്" എന്ന ഭാഷയിൽ പ്രവർത്തനങ്ങളുടെ ഒരു നിശ്ചിത ക്രമം സജ്ജമാക്കേണ്ടത് ആവശ്യമാണ്. അസംബ്ലർ ഈ വിഷയത്തിൽ ഒരു സഹായിയാകും. കമാൻഡുകൾ മെഷീൻ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുന്നതിനൊപ്പം പ്രവർത്തിക്കുന്ന ഒരു യൂട്ടിലിറ്റിയാണിത്. എന്നിരുന്നാലും, ഒരു പ്രോഗ്രാം എഴുതുന്നത് വളരെ അധ്വാനവും സങ്കീർണ്ണവുമായ പ്രക്രിയയാണ്. ഈ ഭാഷ ശ്വാസകോശങ്ങളെ സൃഷ്ടിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല ലളിതമായ പ്രവർത്തനങ്ങൾ. ഓൺ ഈ നിമിഷംഉപയോഗിച്ച ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയും (അസംബ്ലർ മികച്ച രീതിയിൽ പ്രവർത്തിക്കുന്നു) പ്രത്യേകമായി എഴുതാൻ നിങ്ങളെ അനുവദിക്കുന്നു ഫലപ്രദമായ ജോലികൾ, ഇത് ഹാർഡ്‌വെയറിന്റെ പ്രകടനത്തെ വളരെയധികം ബാധിക്കുന്നു. സൂക്ഷ്മ നിർദ്ദേശങ്ങളും ചെറിയ കോഡുകളും സൃഷ്ടിക്കുക എന്നതാണ് പ്രധാന ലക്ഷ്യം. ഈ ഭാഷ നൽകുന്നു കൂടുതൽ സാധ്യതകൾഉദാഹരണത്തിന്, പാസ്കൽ അല്ലെങ്കിൽ സി.

അസംബ്ലി ഭാഷകളുടെ ഒരു ഹ്രസ്വ വിവരണം

എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകളും ലെവലുകളായി തിരിച്ചിരിക്കുന്നു: താഴ്ന്നതും ഉയർന്നതും. അസംബ്ലർ “ഫാമിലി” യുടെ ഏതെങ്കിലും വാക്യഘടനാ സംവിധാനങ്ങളെ അത് ഏറ്റവും സാധാരണമായതിന്റെ ചില ഗുണങ്ങളെ ഉടനടി സംയോജിപ്പിക്കുന്നു എന്ന വസ്തുതയാൽ വേർതിരിച്ചിരിക്കുന്നു. ആധുനിക ഭാഷകൾ. അവർക്ക് മറ്റുള്ളവരുമായി പൊതുവായുള്ളത് അവർക്ക് കമ്പ്യൂട്ടർ സിസ്റ്റം പൂർണ്ണമായും ഉപയോഗിക്കാൻ കഴിയും എന്നതാണ്.

കംപൈലറിന്റെ ഒരു പ്രത്യേകത അതിന്റെ ഉപയോഗ എളുപ്പമാണ്. ഉയർന്ന തലത്തിൽ മാത്രം പ്രവർത്തിക്കുന്നവയിൽ നിന്ന് ഇത് വേർതിരിക്കുന്നു. അത്തരത്തിലുള്ള ഏതെങ്കിലും പ്രോഗ്രാമിംഗ് ഭാഷ നിങ്ങൾ പരിഗണിക്കുകയാണെങ്കിൽ, അസംബ്ലർ ഇരട്ടി വേഗത്തിലും മികച്ചതിലും പ്രവർത്തിക്കുന്നു. അതിൽ എഴുതാൻ വേണ്ടി എളുപ്പമുള്ള പ്രോഗ്രാം, ഇത് കൂടുതൽ സമയം എടുക്കില്ല.

ഭാഷയുടെ ഘടനയെക്കുറിച്ച് ചുരുക്കത്തിൽ

ഭാഷയുടെ പ്രവർത്തനത്തെയും ഘടനയെയും കുറിച്ച് നമ്മൾ പൊതുവായി സംസാരിക്കുകയാണെങ്കിൽ, അതിന്റെ കമാൻഡുകൾ പൂർണ്ണമായും പ്രോസസർ കമാൻഡുകളുമായി പൊരുത്തപ്പെടുന്നുവെന്ന് നമുക്ക് ഉറപ്പിച്ച് പറയാൻ കഴിയും. അതായത്, അസംബ്ലർ മിക്കതും മെമ്മോണിക് കോഡുകൾ ഉപയോഗിക്കുന്നു ഒരു വ്യക്തിക്ക് സുഖപ്രദമായറെക്കോർഡിംഗിനായി.

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, മെമ്മറി സെല്ലുകൾ എഴുതുന്നതിന് അസംബ്ലി വിലാസങ്ങൾക്ക് പകരം നിർദ്ദിഷ്ട ലേബലുകൾ ഉപയോഗിക്കുന്നു. കോഡ് എക്‌സിക്യൂഷൻ പ്രക്രിയയ്‌ക്കൊപ്പം, അവ നിർദ്ദേശങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നവയിലേക്ക് വിവർത്തനം ചെയ്യപ്പെടുന്നു. ഈ ബന്ധു വിലാസങ്ങൾ, പ്രോസസറിന്റെ പ്രവർത്തനത്തെ ബാധിക്കാത്തവ (മെഷീൻ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്തിട്ടില്ല), എന്നാൽ പ്രോഗ്രാമിംഗ് പരിതസ്ഥിതി തന്നെ തിരിച്ചറിയുന്നതിന് അവ ആവശ്യമാണ്.

ഓരോ പ്രോസസറിനും അതിന്റേതായ ഒരു വരിയുണ്ട്. ഈ സാഹചര്യത്തിൽ, വിവർത്തനം ചെയ്തതുൾപ്പെടെ ഏത് പ്രക്രിയയും ശരിയാകും

അസംബ്ലി ഭാഷയിൽ നിരവധി വാക്യഘടനകളുണ്ട്, അവ ലേഖനത്തിൽ ചർച്ചചെയ്യും.

ഭാഷയുടെ പ്രോസ്

അസംബ്ലി ഭാഷയുടെ ഏറ്റവും പ്രധാനപ്പെട്ടതും സൗകര്യപ്രദവുമായ ഉപകരണം, അതിൽ പ്രോസസറിനായി നിങ്ങൾക്ക് ഏത് പ്രോഗ്രാമും എഴുതാം, അത് വളരെ ഒതുക്കമുള്ളതായിരിക്കും. കോഡ് വലുതായി മാറുകയാണെങ്കിൽ, ചില പ്രക്രിയകൾ റാമിലേക്ക് റീഡയറക്‌ട് ചെയ്യപ്പെടും. മാത്രമല്ല, അവർ എല്ലാം വളരെ വേഗത്തിലും പരാജയങ്ങളില്ലാതെയും ചെയ്യുന്നു, തീർച്ചയായും, യോഗ്യതയുള്ള ഒരു പ്രോഗ്രാമർ അവരെ നിയന്ത്രിക്കുന്നില്ലെങ്കിൽ.

ഡ്രൈവറുകൾ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ, ബയോസ്, കമ്പൈലറുകൾ, ഇന്റർപ്രെട്ടറുകൾ തുടങ്ങിയവയെല്ലാം അസംബ്ലി ഭാഷയിലുള്ള പ്രോഗ്രാമുകളാണ്.

മെഷീനിൽ നിന്ന് മെഷീനിലേക്ക് വിവർത്തനം ചെയ്യുന്ന ഒരു ഡിസ്അസംബ്ലർ ഉപയോഗിക്കുമ്പോൾ, ഈ അല്ലെങ്കിൽ ആ സിസ്റ്റം ടാസ്ക് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് എളുപ്പത്തിൽ മനസ്സിലാക്കാൻ കഴിയും, അതിന് വിശദീകരണമൊന്നുമില്ലെങ്കിലും. എന്നിരുന്നാലും, പ്രോഗ്രാമുകൾ എളുപ്പമാണെങ്കിൽ മാത്രമേ ഇത് സാധ്യമാകൂ. നിർഭാഗ്യവശാൽ, നിസ്സാരമല്ലാത്ത കോഡുകൾ മനസ്സിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്.

ഭാഷയുടെ പോരായ്മകൾ

നിർഭാഗ്യവശാൽ, പുതിയ പ്രോഗ്രാമർമാർക്കും (പലപ്പോഴും പ്രൊഫഷണലുകൾക്കും) ഭാഷ മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടാണ്. അസംബ്ലർ ആവശ്യപ്പെടുന്നു വിശദമായ വിവരണം ആവശ്യമായ കമാൻഡ്. മെഷീൻ കമാൻഡുകൾ ഉപയോഗിക്കേണ്ടതിന്റെ ആവശ്യകത കാരണം, തെറ്റായ പ്രവർത്തനങ്ങളുടെ സാധ്യതയും നിർവ്വഹണത്തിന്റെ സങ്കീർണ്ണതയും വർദ്ധിക്കുന്നു.

ഏറ്റവും കൂടുതൽ എഴുതാൻ വേണ്ടി ഒരു ലളിതമായ പ്രോഗ്രാം, പ്രോഗ്രാമർ യോഗ്യനായിരിക്കണം, അവന്റെ അറിവിന്റെ നിലവാരം വേണ്ടത്ര ഉയർന്നതാണ്. ശരാശരി സ്പെഷ്യലിസ്റ്റ്, നിർഭാഗ്യവശാൽ, പലപ്പോഴും മോശം കോഡ് എഴുതുന്നു.

പ്രോഗ്രാം സൃഷ്‌ടിച്ച പ്ലാറ്റ്‌ഫോം അപ്‌ഡേറ്റ് ചെയ്‌തിട്ടുണ്ടെങ്കിൽ, എല്ലാ കമാൻഡുകളും സ്വമേധയാ മാറ്റിയെഴുതണം - ഇത് ഭാഷയ്ക്ക് തന്നെ ആവശ്യമാണ്. അസംബ്ലർ പ്രവർത്തനത്തെ പിന്തുണയ്ക്കുന്നില്ല യാന്ത്രിക നിയന്ത്രണംപ്രക്രിയകളുടെ പ്രവർത്തനക്ഷമതയും ഏതെങ്കിലും ഘടകങ്ങളുടെ മാറ്റിസ്ഥാപിക്കലും.

ഭാഷാ കമാൻഡുകൾ

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ഓരോ പ്രോസസ്സറിനും അതിന്റേതായ കമാൻഡുകൾ ഉണ്ട്. ഏത് തരത്താലും തിരിച്ചറിയപ്പെടുന്ന ഏറ്റവും ലളിതമായ ഘടകങ്ങൾ ഇനിപ്പറയുന്ന കോഡുകളാണ്:

നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുന്നു

ഭാഷയിൽ പ്രോഗ്രാമിംഗ് മൈക്രോകൺട്രോളറുകൾ (അസംബ്ലർ ഇത് അനുവദിക്കുകയും പ്രവർത്തനത്തെ നന്നായി നേരിടുകയും ചെയ്യുന്നു) താഴ്ന്ന നിലമിക്ക കേസുകളിലും അത് വിജയകരമായി അവസാനിക്കുന്നു. പരിമിതമായ വിഭവങ്ങൾ ഉപയോഗിച്ച് പ്രോസസ്സറുകൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്. 32-ബിറ്റ് സാങ്കേതികവിദ്യയ്ക്കായി നൽകിയ ഭാഷതികച്ചും യോജിക്കുന്നു. നിങ്ങൾക്ക് പലപ്പോഴും കോഡിൽ നിർദ്ദേശങ്ങൾ കാണാൻ കഴിയും. ഇത് എന്താണ്? പിന്നെ എന്തിനുവേണ്ടിയാണ് ഇത് ഉപയോഗിക്കുന്നത്?

ഒന്നാമതായി, നിർദ്ദേശങ്ങൾ യന്ത്രഭാഷയിലേക്ക് വിവർത്തനം ചെയ്തിട്ടില്ലെന്ന് ഊന്നിപ്പറയേണ്ടത് ആവശ്യമാണ്. കംപൈലർ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് അവർ നിയന്ത്രിക്കുന്നു. കമാൻഡുകൾ പോലെയല്ല, ഈ പരാമീറ്ററുകൾ, ഉള്ളത് വിവിധ പ്രവർത്തനങ്ങൾ, വ്യത്യസ്തമല്ല നന്ദി വ്യത്യസ്ത പ്രോസസ്സറുകൾ, എന്നാൽ മറ്റൊരു വിവർത്തകന്റെ ചെലവിൽ. പ്രധാന നിർദ്ദേശങ്ങളിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു:

പേരിന്റെ ഉത്ഭവം

ഭാഷയ്ക്ക് അതിന്റെ പേര് എങ്ങനെ ലഭിച്ചു - "അസംബ്ലർ"? ഡാറ്റ എൻക്രിപ്റ്റ് ചെയ്യുന്ന ഒരു വിവർത്തകനെയും കംപൈലറെയും കുറിച്ചാണ് നമ്മൾ സംസാരിക്കുന്നത്. ഇംഗ്ലീഷിൽ അസംബ്ലർ എന്നാൽ അസംബ്ലർ എന്നല്ലാതെ മറ്റൊന്നുമല്ല. പ്രോഗ്രാം സ്വമേധയാ കൂട്ടിച്ചേർക്കപ്പെട്ടില്ല; ഒരു ഓട്ടോമാറ്റിക് ഘടന ഉപയോഗിച്ചു. മാത്രമല്ല, ഇപ്പോൾ, ഉപയോക്താക്കൾക്കും സ്പെഷ്യലിസ്റ്റുകൾക്കും നിബന്ധനകൾ തമ്മിലുള്ള വ്യത്യാസം ഇതിനകം നഷ്ടപ്പെട്ടു. പ്രോഗ്രാമിംഗ് ഭാഷകളെ അസംബ്ലർ എന്ന് വിളിക്കാറുണ്ട്, എന്നിരുന്നാലും ഇത് ഒരു യൂട്ടിലിറ്റി മാത്രമാണ്.

പൊതുവായ കൂട്ടായ നാമം കാരണം, താഴ്ന്ന നിലവാരത്തിലുള്ള ഒരു ഭാഷ (അല്ലെങ്കിൽ അതിനുള്ള സ്റ്റാൻഡേർഡ് മാനദണ്ഡങ്ങൾ) ഉണ്ടെന്ന് ചില ആളുകൾ തെറ്റായി വിശ്വസിക്കുന്നു. ഏത് ഘടനയെക്കുറിച്ചാണ് നമ്മൾ സംസാരിക്കുന്നതെന്ന് പ്രോഗ്രാമർക്ക് മനസിലാക്കാൻ, ഒരു പ്രത്യേക അസംബ്ലി ഭാഷ ഏത് പ്ലാറ്റ്ഫോമിനായി ഉപയോഗിക്കുന്നുവെന്ന് വ്യക്തമാക്കേണ്ടത് ആവശ്യമാണ്.

മാക്രോ എന്നാൽ

താരതമ്യേന പുതിയ അസംബ്ലി ഭാഷകൾക്ക് മാക്രോ സവിശേഷതകൾ ഉണ്ട്. അവ ഒരു പ്രോഗ്രാം എഴുതുന്നതും പ്രവർത്തിപ്പിക്കുന്നതും എളുപ്പമാക്കുന്നു. അവരുടെ സാന്നിധ്യത്തിന് നന്ദി, വിവർത്തകൻ എഴുതിയ കോഡ് പല മടങ്ങ് വേഗത്തിൽ നടപ്പിലാക്കുന്നു. ഒരു സോപാധിക തിരഞ്ഞെടുപ്പ് സൃഷ്ടിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഒരു വലിയ കമാൻഡുകൾ എഴുതാൻ കഴിയും, എന്നാൽ മാക്രോ ടൂളുകൾ ഉപയോഗിക്കുന്നത് എളുപ്പമാണ്. ഒരു നിബന്ധന പാലിച്ചാലും ഇല്ലെങ്കിലും പ്രവർത്തനങ്ങൾക്കിടയിൽ വേഗത്തിൽ മാറാൻ അവ നിങ്ങളെ അനുവദിക്കും.

മാക്രോ ഭാഷാ നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കുമ്പോൾ, പ്രോഗ്രാമർക്ക് അസംബ്ലർ മാക്രോകൾ ലഭിക്കും. ചിലപ്പോൾ ഇത് വ്യാപകമായി ഉപയോഗിക്കാം, ചിലപ്പോൾ അത് പ്രവർത്തന സവിശേഷതകൾഒരു ടീമായി ചുരുങ്ങി. കോഡിലെ അവരുടെ സാന്നിധ്യം പ്രവർത്തിക്കുന്നത് എളുപ്പമാക്കുന്നു, ഇത് കൂടുതൽ മനസ്സിലാക്കാവുന്നതും ദൃശ്യപരവുമാക്കുന്നു. എന്നിരുന്നാലും, നിങ്ങൾ ഇപ്പോഴും ശ്രദ്ധിക്കണം - ചില സന്ദർഭങ്ങളിൽ, മാക്രോകൾ, നേരെമറിച്ച്, സാഹചര്യം കൂടുതൽ വഷളാക്കുന്നു.

ഒരുപാട് വർഷങ്ങൾക്ക് ശേഷം എല്ലാം വിജയിക്കാതെ, വേരുകളിലേക്ക് മടങ്ങാൻ ഞാൻ തീരുമാനിച്ചു. പ്രോഗ്രാമിംഗിലേക്ക്. വീണ്ടും, ഈ മേഖലയിലെ നിരവധി "ആധുനിക നേട്ടങ്ങൾ" കണക്കിലെടുത്ത്, യഥാർത്ഥത്തിൽ എന്താണ് നഷ്ടപ്പെട്ടതെന്ന് തീരുമാനിക്കാൻ ബുദ്ധിമുട്ടായിരുന്നു, അത് മനോഹരവും ഉപയോഗപ്രദവുമാകും. കുറേയേറെ കാര്യങ്ങൾ ചെറുതായി പരീക്ഷിച്ചിട്ടും, കമ്പ്യൂട്ടറുമായി പരിചയപ്പെട്ടതിന്റെ ആദ്യ ദിവസങ്ങളിൽ നിന്ന് (സർ സിൻക്ലെയറിന്റെ സൃഷ്ടിയുടെ ഒരു പകർപ്പ് പോലും) - അസംബ്ലി ഭാഷയിലെ പ്രോഗ്രാമിംഗിലേക്ക് - ഞാൻ വരച്ചിടത്തേക്ക് മടങ്ങാൻ തീരുമാനിച്ചു. വാസ്തവത്തിൽ, ഒരു കാലത്ത് എനിക്ക് അസംബ്ലറെ നന്നായി അറിയാമായിരുന്നു (ഇൻ ഈ സാഹചര്യത്തിൽഞാൻ x86 നെക്കുറിച്ചാണ് സംസാരിക്കുന്നത്), പക്ഷേ ഏകദേശം 15 വർഷമായി ഞാൻ അതിൽ ഒന്നും എഴുതിയിട്ടില്ല. അതിനാൽ, ഇത് "ധൂർത്തപുത്രന്റെ" ഒരുതരം തിരിച്ചുവരവാണ്.
എന്നാൽ ഇവിടെ ആദ്യ നിരാശയാണ് കാത്തിരുന്നത്. ഇൻറർനെറ്റിൽ കണ്ടെത്തിയ അസംബ്ലറിനെക്കുറിച്ചുള്ള പുസ്തകങ്ങൾ, മാനുവലുകൾ, മറ്റ് റഫറൻസ് ബുക്കുകൾ എന്നിവയിൽ എന്റെ ഖേദമുണ്ട്, അസംബ്ലറിൽ എങ്ങനെ പ്രോഗ്രാം ചെയ്യണം, എന്തുകൊണ്ടാണ് ഇത് അങ്ങനെ ചെയ്യുന്നത്, അത് എന്താണ് നൽകുന്നത് എന്നതിനെക്കുറിച്ചുള്ള ഏറ്റവും കുറഞ്ഞ വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു.

മറ്റൊരു മേഖലയിൽ നിന്നുള്ള ഉദാഹരണം

നമ്മൾ ബോക്സിംഗ് ഒരു ഉദാഹരണമായി എടുക്കുകയാണെങ്കിൽ, അത്തരം എല്ലാ മാനുവലുകളും എങ്ങനെ ഒരു സ്ട്രൈക്ക് നടത്താമെന്നും തറയിൽ നിൽക്കുമ്പോൾ നീങ്ങാമെന്നും പഠിപ്പിക്കുന്നു, എന്നാൽ ബോക്സിംഗ് - ബോക്സിംഗ്, "അനുവദനീയമായ പഞ്ചിംഗ്" അല്ല - തീർത്തും കാണുന്നില്ല. അതായത്, കോമ്പിനേഷൻ വർക്ക്, മോതിരം ഉപയോഗിക്കുന്നതിന്റെ സവിശേഷതകൾ, പ്രതിരോധ പ്രവർത്തനങ്ങൾ, യുദ്ധത്തിന്റെ തന്ത്രപരമായ ഘടന, പ്രത്യേകിച്ച്, യുദ്ധ തന്ത്രം എന്നിവ പരിഗണിക്കപ്പെടുന്നില്ല. പഞ്ചിംഗ് ബാഗ് അടിച്ച് നേരെ റിങ്ങിലേക്ക് പോകാൻ അവർ ഒരാളെ പഠിപ്പിച്ചു. ഇത് അടിസ്ഥാനപരമായി തെറ്റാണ്. എന്നാൽ അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിലെ മിക്കവാറും എല്ലാ "പാഠപുസ്തകങ്ങളും" "ഗൈഡുകളും" ഇങ്ങനെയാണ് ക്രമീകരിച്ചിരിക്കുന്നത്.

എന്നിരുന്നാലും, സാധാരണ പുസ്തകങ്ങൾ ഉണ്ടായിരിക്കണം; മിക്കവാറും, "സ്ലാഗ്" എന്ന പർവതത്തിന് കീഴിൽ ഞാൻ അവ കണ്ടെത്തിയില്ല. അതിനാൽ, വാസ്തുവിദ്യ, ഓർമ്മപ്പെടുത്തൽ, എല്ലാത്തരം തന്ത്രങ്ങളും "2 വിരലുകളിൽ നിന്ന് എങ്ങനെ നിർമ്മിക്കാം" എന്നതിന്റെ ആഗോള വിവരണം ഉപയോഗിച്ച് അറിവ് നിറയ്ക്കുന്നതിന് മുമ്പ്, "പ്രത്യയശാസ്ത്ര" വീക്ഷണകോണിൽ നിന്ന് അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിന്റെ പ്രശ്നത്തെ സമീപിക്കാം.

ഐഡിൽ?

ഒരു ചെറിയ കുറിപ്പ്, വാചകത്തിൽ നിലവിലുള്ളതിൽ നിന്ന് വ്യത്യസ്തമായ ഒരു വർഗ്ഗീകരണം ഉപയോഗിക്കും. എന്നിരുന്നാലും, ഇത് “സത്യത്തിന്റെ നിറത്തെക്കുറിച്ചുള്ള തർക്കങ്ങൾക്ക്” ഒരു കാരണമല്ല; പ്രോഗ്രാമിംഗിനെക്കുറിച്ചുള്ള രചയിതാവിന്റെ കാഴ്ചപ്പാട് ഈ രൂപത്തിൽ വിശദീകരിക്കുന്നത് എളുപ്പമാണ്.

അതിനാൽ, ഇന്ന്, പ്രോഗ്രാമർമാർക്ക് സന്തോഷത്തിന്റെ ഒരു യുഗം വന്നിരിക്കുന്നുവെന്ന് തോന്നുന്നു. വലിയ തിരഞ്ഞെടുപ്പ്എല്ലാ അവസരങ്ങൾക്കും ആഗ്രഹങ്ങൾക്കും വേണ്ടിയുള്ള ഫണ്ടുകൾ. ഇവിടെ നിങ്ങൾക്ക് ദശലക്ഷക്കണക്കിന് “ഫ്രെയിം വർക്കുകൾ”/“പാറ്റേണുകൾ”/“ടെംപ്ലേറ്റുകൾ”/“ലൈബ്രറികൾ”, “പ്രോഗ്രാമിംഗ് എളുപ്പമാക്കുന്ന” ആയിരക്കണക്കിന് ടൂളുകൾ, നൂറുകണക്കിന് ഭാഷകളും ഭാഷകളും, ഡസൻ കണക്കിന് രീതിശാസ്ത്രങ്ങളും പ്രോഗ്രാമിംഗിലേക്കുള്ള വിവിധ സമീപനങ്ങളും ഉണ്ട്. എടുക്കുക - എനിക്കത് വേണ്ട. എന്നാൽ അത് "എടുക്കുന്നില്ല". മതപരമായ വിശ്വാസങ്ങളിലല്ല, മറിച്ച് രുചിയില്ലാത്ത എന്തെങ്കിലും കഴിക്കാനുള്ള ശ്രമമാണെന്ന് തോന്നുന്നു എന്നതാണ് കാര്യം. നിങ്ങൾക്ക് വേണമെങ്കിൽ, ഉത്സാഹമുള്ളവരാണെങ്കിൽ, തീർച്ചയായും നിങ്ങൾക്ക് ഇതിനോട് പൊരുത്തപ്പെടാൻ കഴിയും. പക്ഷേ, പ്രോഗ്രാമിംഗിലേക്ക് മടങ്ങുമ്പോൾ, വാഗ്ദാനം ചെയ്യുന്ന മിക്കതിലും സാങ്കേതിക സൗന്ദര്യമില്ല - ധാരാളം “ക്രച്ചുകൾ” മാത്രമേ കാണാനാകൂ. തൽഫലമായി, ഈ "നേട്ടങ്ങൾ" ഉപയോഗിക്കുമ്പോൾ, "ആർട്ടിസ്റ്റുകളുടെ ബ്രഷിന്റെ" കീഴിൽ നിന്ന്, മയക്കുന്ന ലാൻഡ്സ്കേപ്പുകൾക്ക് പകരം, ശക്തമായ ഒരു "അമൂർത്തീകരണം" പുറത്തുവരുന്നു, അല്ലെങ്കിൽ ജനപ്രിയ പ്രിന്റുകൾ - നിങ്ങൾ ഭാഗ്യവാനാണെങ്കിൽ. മിക്ക പ്രോഗ്രാമർമാരും യഥാർത്ഥത്തിൽ വളരെ സാധാരണക്കാരും അജ്ഞരും ജനിതക തലത്തിൽ പ്രശ്നങ്ങളുള്ളവരുമാണോ? ഞാന് അങ്ങനെ വിചാരിക്കുന്നില്ല. അപ്പോൾ എന്താണ് കാരണം?
ഇന്ന് പ്രോഗ്രാമിംഗിന്റെ നിരവധി ആശയങ്ങളും വഴികളും ഉണ്ട്. അവയിൽ ഏറ്റവും “ഫാഷനബിൾ” നോക്കാം.

• നിർബന്ധിത പ്രോഗ്രാമിംഗ് - ഈ സമീപനത്തിൽ, ഒരു പ്രശ്നം പരിഹരിക്കുന്നതിലേക്ക് നയിക്കുന്ന പ്രവർത്തനങ്ങളുടെ ഒരു ക്രമം പ്രോഗ്രാമർ വ്യക്തമാക്കുന്നു. യുക്തിപരമായി സ്വതന്ത്രമായ പ്രവർത്തനങ്ങൾ (മൊഡ്യൂളുകൾ, പ്രവർത്തനങ്ങൾ, നടപടിക്രമങ്ങൾ) നടത്തുന്ന ഭാഗങ്ങളായി പ്രോഗ്രാമിനെ വിഭജിക്കുന്നതിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ഇത്. എന്നാൽ ടൈപ്പ് ചെയ്ത സമീപനത്തിൽ നിന്ന് വ്യത്യസ്തമായി (താഴെ കാണുക), ഉണ്ട് പ്രധാന സവിശേഷത- വേരിയബിളുകളുടെ "ടൈപ്പിംഗ്" അഭാവം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, "വേരിയബിൾ തരം" എന്ന ആശയം ഇല്ല; പകരം, ഒരേ വേരിയബിളിന്റെ മൂല്യങ്ങൾക്ക് വ്യത്യസ്ത തരങ്ങളുണ്ടാകാമെന്ന ധാരണ ഉപയോഗിക്കുന്നു. പ്രമുഖ പ്രതിനിധികൾ ഈ സമീപനംഅടിസ്ഥാന, REXX, MUMPS എന്നിവയാണ്.
• ടൈപ്പ് ചെയ്ത പ്രോഗ്രാമിംഗ് - പരിഷ്ക്കരണം അനിവാര്യമായ പ്രോഗ്രാമിംഗ്പ്രോഗ്രാമറും സിസ്റ്റവും വേരിയബിളുകളുടെ സാധ്യമായ മൂല്യങ്ങൾ പരിമിതപ്പെടുത്തുമ്പോൾ. ഏറ്റവും പ്രശസ്തമായ ഭാഷകൾ പാസ്കൽ, സി.
• ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ആണ് കൂടുതൽ ഗണിതശാസ്ത്ര രീതിഒരു പ്രശ്നം പരിഹരിക്കുമ്പോൾ, ഫംഗ്ഷനുകളുടെ ഒരു ശ്രേണി "നിർമ്മാണം" ചെയ്യുന്നതിൽ പരിഹാരം അടങ്ങിയിരിക്കുമ്പോൾ (അതനുസരിച്ച്, നഷ്‌ടമായവ സൃഷ്ടിക്കുന്നു), പ്രശ്‌നത്തിന്റെ പരിഹാരത്തിലേക്ക് നയിക്കുന്നു. ഉദാഹരണമായി: ലിസ്പ്, ഫോർത്ത്.
• സന്ദേശങ്ങൾ കൈമാറുന്ന ഒബ്‌ജക്‌റ്റുകൾ/എക്‌സിക്യൂട്ടീവ് ഘടകങ്ങൾ എന്നിവ ഉൾപ്പെടുന്ന ഒരു മോഡൽ/നെറ്റ്‌വർക്ക് പ്രോഗ്രാമർ നിർമ്മിക്കുന്ന ഒരു സമീപനമാണ് ഓട്ടോമാറ്റിക് പ്രോഗ്രാമിംഗ്, ഇവ രണ്ടും അവരുടെ ആന്തരിക "നില" മാറ്റുന്നു/സംഭരിക്കുന്നു, പുറം ലോകവുമായി സംവദിക്കാൻ കഴിയും. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഇതിനെയാണ് സാധാരണയായി വിളിക്കുന്നത് " ഒബ്ജക്റ്റ് പ്രോഗ്രാമിംഗ്"(വസ്തു-അധിഷ്ഠിതമല്ല). ഈ രീതിയിലുള്ള പ്രോഗ്രാമിംഗ് സ്മോൾടോക്കിൽ അവതരിപ്പിച്ചിരിക്കുന്നു.

എന്നാൽ മറ്റു പല ഭാഷകളുടെ കാര്യമോ? ചട്ടം പോലെ, ഇവ ഇതിനകം "മ്യൂട്ടന്റുകളാണ്". ഉദാഹരണത്തിന്, തരം അധിഷ്ഠിതവും ഓട്ടോമാറ്റ സമീപനങ്ങളും മിശ്രണം ചെയ്യുന്നത് "ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗ്" നൽകി.

നമ്മൾ കാണുന്നതുപോലെ, ഓരോ സമീപനവും (നിർദ്ദിഷ്ട നടപ്പാക്കലുകളുടെ പരിമിതികൾ കണക്കിലെടുക്കാതെ പോലും) പ്രോഗ്രാമിംഗ് സാങ്കേതികതയിൽ തന്നെ അതിന്റേതായ നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്തുന്നു. എന്നാൽ അത് മറിച്ചാകാൻ കഴിയില്ല. നിർഭാഗ്യവശാൽ, ഈ നിയന്ത്രണങ്ങൾ പലപ്പോഴും "ആശയത്തിന്റെ പരിശുദ്ധി നിലനിർത്താൻ" കൃത്രിമമായി സൃഷ്ടിക്കപ്പെടുന്നു. തൽഫലമായി, പ്രോഗ്രാമർ ആദ്യം കണ്ടെത്തിയ പരിഹാരത്തെ ഏതെങ്കിലും തരത്തിൽ ഉപയോഗിച്ച ഭാഷയുടെ അല്ലെങ്കിൽ ഉപയോഗിച്ച "പാറ്റേണിന്റെ" പ്രത്യയശാസ്ത്രവുമായി പൊരുത്തപ്പെടുന്ന ഒരു രൂപത്തിലേക്ക് "വികൃതമാക്കണം". രൂപകൽപ്പനയുടെയും വികസനത്തിന്റെയും പുതിയ വിചിത്രമായ രീതികളും രീതികളും കണക്കിലെടുക്കാതെയാണ് ഇത്.

അസംബ്ലറിൽ പ്രോഗ്രാം ചെയ്യുമ്പോൾ, നമുക്ക് എന്ത് വേണമെങ്കിലും ചെയ്യാൻ സ്വാതന്ത്ര്യമുണ്ടെന്ന് തോന്നുന്നു, ഹാർഡ്‌വെയർ നമ്മെ അനുവദിക്കുന്നു. എന്നാൽ ഞങ്ങൾ ഉപയോഗിക്കാൻ ആഗ്രഹിക്കുന്ന ഉടൻ " സാർവത്രിക ഡ്രൈവർ"ഏത് തരത്തിലുള്ള ഉപകരണങ്ങൾക്കും, ഡ്രൈവർ ഉപയോഗിക്കുന്നതിനുള്ള നിർദ്ദേശിത (സ്റ്റാൻഡേർഡ്) സമീപനങ്ങൾക്കും വഴികൾക്കുമായി "സർഗ്ഗാത്മകതയുടെ" സ്വാതന്ത്ര്യം കൈമാറാൻ ഞങ്ങൾ നിർബന്ധിതരാകുന്നു. മറ്റ് സഹപ്രവർത്തകരുടെ ജോലി ഉപയോഗിക്കാനുള്ള അവസരം അല്ലെങ്കിൽ ഞങ്ങളുടെ അധ്വാനത്തിന്റെ ഫലം അവർക്ക് നൽകാനുള്ള അവസരം ആവശ്യമായി വന്നാലുടൻ, പ്രോഗ്രാമിന്റെ ഭാഗങ്ങൾ തമ്മിലുള്ള ഇടപെടൽ തിരഞ്ഞെടുക്കാനുള്ള സ്വാതന്ത്ര്യം ചിലർക്ക് അംഗീകരിക്കാൻ ഞങ്ങൾ നിർബന്ധിതരാകുന്നു. / സ്റ്റാൻഡേർഡ് രീതികൾ.

അങ്ങനെ, ആളുകൾ പലപ്പോഴും അസംബ്ലറിൽ പ്രവേശിക്കാൻ ശ്രമിക്കുന്ന "സ്വാതന്ത്ര്യം" പലപ്പോഴും ഒരു "കെട്ടുകഥ" ആയി മാറുന്നു. ഇത് (പരിമിതികളെക്കുറിച്ചും അവ സംഘടിപ്പിക്കുന്നതിനുള്ള വഴികളെക്കുറിച്ചും) എന്റെ അഭിപ്രായത്തിൽ, കൂടുതൽ ശ്രദ്ധ നൽകണം. നിയന്ത്രണങ്ങൾ ഏർപ്പെടുത്തുന്നതിന്റെ കാരണവും അസംബ്ലി ഭാഷയെ പല ഭാഷകളിൽ നിന്നും വേർതിരിക്കുന്നത് എന്താണെന്നും പ്രോഗ്രാമർ മനസ്സിലാക്കണം ഉയർന്ന തലം, അത്തരമൊരു ആവശ്യം വന്നാൽ അവ മാറ്റാൻ കഴിയും. എന്നിരുന്നാലും, ഇപ്പോൾ ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാമർ ഉയർന്ന തലത്തിലുള്ള ഭാഷകൾ അവതരിപ്പിക്കുന്ന നിയന്ത്രണങ്ങൾ സഹിക്കാൻ നിർബന്ധിതനാകുന്നു, അവയിൽ പ്രോഗ്രാമിംഗ് ചെയ്യുന്നവർക്ക് “കാരറ്റ്” ലഭ്യമല്ല. ഒരു വശത്ത്, ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ഇതിനകം നടപ്പിലാക്കിയ നിരവധി ഫംഗ്ഷനുകൾ നൽകുന്നു, റെഡിമെയ്ഡ് ലൈബ്രറികളും അതിലേറെയും ഉണ്ട്. എന്നാൽ അവ ഉപയോഗിക്കുന്നതിനുള്ള വഴികൾ, ഒരു പ്രത്യേക ഉദ്ദേശ്യമായി, അസംബ്ലി ഭാഷയിൽ എഴുതിയ പ്രോഗ്രാമുകളിൽ നിന്ന് അവരെ വിളിക്കുന്നത് കണക്കിലെടുക്കാതെ നടപ്പിലാക്കുന്നു, കൂടാതെ x86 ആർക്കിടെക്ചറിനായുള്ള പ്രോഗ്രാമിംഗിന്റെ യുക്തിക്ക് വിരുദ്ധമായി പോലും. തൽഫലമായി, ഇപ്പോൾ അസംബ്ലി ഭാഷയിൽ വിളിക്കുന്ന OS ഫംഗ്‌ഷനുകളോ ബാഹ്യ ഹൈ-ലെവൽ ഭാഷാ ലൈബ്രറികളോ ഉപയോഗിച്ച് പ്രോഗ്രാമിംഗ് ചെയ്യുന്നത് “ഭയം”, “ഭീതി” എന്നിവയാണ്.

കാടിനുള്ളിലേക്ക് കടക്കുമ്പോൾ കനം കൂടും

അതിനാൽ, അസംബ്ലർ വളരെ ലളിതമാണെങ്കിലും, നിങ്ങൾക്ക് അത് ഉപയോഗിക്കാൻ കഴിയണമെന്ന് ഞങ്ങൾ മനസ്സിലാക്കി. ഞങ്ങളുടെ പ്രോഗ്രാം പ്രവർത്തിക്കുന്ന എക്‌സിക്യൂഷൻ പരിതസ്ഥിതിയുമായി സംവദിക്കേണ്ടതിന്റെ ആവശ്യകതയാണ് പ്രധാന സംയോജനം. ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിലെ പ്രോഗ്രാമർമാർക്ക് ഇതിനകം ആക്സസ് ഉണ്ടെങ്കിൽ ആവശ്യമായ ലൈബ്രറികൾ, ഫംഗ്‌ഷനുകൾ, നിരവധി അവസരങ്ങൾക്കുള്ള സബ്‌റൂട്ടീനുകൾ, കൂടാതെ അവർക്ക് പുറം ലോകവുമായി ഇടപഴകാനുള്ള വഴികളിലേക്ക് പ്രവേശനമുണ്ട്, ഭാഷയുടെ ആശയവുമായി പൊരുത്തപ്പെടുന്ന രൂപത്തിൽ, പിന്നീട് ഒരു അസംബ്ലർ പ്രോഗ്രാമർക്ക് ഉയർന്നുവരുന്ന എല്ലാത്തരം തടസ്സങ്ങളുടെയും മുൾപടർപ്പിലൂടെ സഞ്ചരിക്കേണ്ടതുണ്ട്. സ്ക്രാച്ച്. കംപൈൽ ചെയ്യുമ്പോൾ ഉയർന്ന തലത്തിലുള്ള ഭാഷകൾ സൃഷ്ടിക്കുന്നത് എന്താണെന്ന് നോക്കുമ്പോൾ, കംപൈലറുകൾ എഴുതിയവർക്ക് x86 ആർക്കിടെക്ചറുള്ള ഒരു പ്രൊസസർ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് അറിയില്ല, അല്ലെങ്കിൽ രണ്ടിൽ ഒന്ന് (സി).

അതിനാൽ, നമുക്ക് ഇത് ക്രമത്തിൽ എടുക്കാം. പ്രോഗ്രാമിംഗ്, ഒന്നാമതായി, എഞ്ചിനീയറിംഗ്, അതായത്, ശാസ്ത്രീയ സർഗ്ഗാത്മകത ഫലപ്രദമായ (വിശ്വാസ്യത, ലഭ്യമായ വിഭവങ്ങളുടെ ഉപയോഗം, നടപ്പാക്കൽ സമയം, ഉപയോഗത്തിന്റെ എളുപ്പം) എന്നിവയെ ലക്ഷ്യം വച്ചുള്ളതാണ്. പ്രായോഗിക പ്രശ്നങ്ങൾ. കൂടാതെ, ഏതൊരു എഞ്ചിനീയറിംഗിന്റെയും അടിസ്ഥാനം ഒരു സിസ്റ്റം സമീപനമാണ്. അതായത്, സമ്പൂർണ്ണവും അനുയോജ്യവുമായ ശൂന്യതയിൽ പ്രവർത്തിക്കുന്ന ഒരുതരം "അവിഭാജ്യമായ" ബ്ലാക്ക് ബോക്സായി ഒരു പരിഹാരവും കണക്കാക്കാനാവില്ല.

മറ്റൊരു മേഖലയിൽ നിന്നുള്ള മറ്റൊരു ഉദാഹരണം

തിളങ്ങുന്ന ഉദാഹരണമായി വ്യവസ്ഥാപിത സമീപനംയുഎസ്എയിലെ ട്രക്കുകളുടെ ഉത്പാദനം നിങ്ങൾക്ക് ഉദ്ധരിക്കാം. ഈ സാഹചര്യത്തിൽ, ട്രക്ക് നിർമ്മാതാവ് ഫ്രെയിം, ക്യാബ് നിർമ്മാതാവ് + ഡിസൈനർ അസംബ്ലർ മാത്രമാണ്. മറ്റെല്ലാം (എഞ്ചിൻ, ട്രാൻസ്മിഷൻ, സസ്പെൻഷൻ, ഇലക്ട്രിക്കൽ ഉപകരണങ്ങൾ മുതലായവ) ഉപഭോക്താവിന്റെ ആഗ്രഹങ്ങളെ അടിസ്ഥാനമാക്കിയാണ് എടുക്കുന്നത്. ഒരു ഉപഭോക്താവ് ഡെട്രോയിറ്റ് ഡീസലിൽ നിന്നുള്ള ഒരു എഞ്ചിൻ, ഒരു ഫുള്ളർ മാനുവൽ ട്രാൻസ്മിഷൻ, ചില ഡാനയിൽ നിന്നുള്ള ലീഫ് സ്പ്രിംഗ് സസ്പെൻഷൻ എന്നിവ ഉപയോഗിച്ച് ഒരു നിശ്ചിത കെൻവർത്ത് സ്വന്തമാക്കാൻ ആഗ്രഹിച്ചു - ദയവായി. ഈ ഉപഭോക്താവിന്റെ ഒരു സുഹൃത്തിന് അതേ കെൻവർത്ത് മോഡൽ ആവശ്യമായിരുന്നു, എന്നാൽ "നേറ്റീവ്" പാക്കർ എഞ്ചിൻ, മറ്റൊരു നിർമ്മാതാവിൽ നിന്നുള്ള ആലിസൺ ഓട്ടോമാറ്റിക് ട്രാൻസ്മിഷനും എയർ സസ്പെൻഷനും - എളുപ്പമാണ്! യുഎസ്എയിലെ എല്ലാ ട്രക്ക് അസംബ്ലർമാരും അങ്ങനെ തന്നെ. അതായത്, ഓരോ മൊഡ്യൂളും അതേ ആവശ്യത്തിനായി മറ്റൊന്ന് ഉപയോഗിച്ച് മാറ്റി നിലവിലുള്ളവയിൽ തടസ്സമില്ലാതെ ഡോക്ക് ചെയ്യാവുന്ന ഒരു സംവിധാനമാണ് ട്രക്ക്. മാത്രമല്ല, ഡോക്കിംഗ് മൊഡ്യൂളുകളുടെ രീതി പരമാവധി ലഭ്യമായ വൈവിധ്യവും സൗകര്യവും ഉപയോഗിച്ചാണ് നിർമ്മിച്ചിരിക്കുന്നത് കൂടുതൽ വിപുലീകരണംപ്രവർത്തനക്ഷമത. ഒരു എഞ്ചിനീയർ പരിശ്രമിക്കേണ്ടത് ഇതാണ്.

നിർഭാഗ്യവശാൽ, നമുക്ക് ഉള്ളത് കൊണ്ട് ജീവിക്കേണ്ടിവരും, എന്നാൽ ഭാവിയിൽ ഇത് ഒഴിവാക്കണം. അതിനാൽ, ഒരു പ്രോഗ്രാം സാരാംശത്തിൽ, മൊഡ്യൂളുകളുടെ ഒരു കൂട്ടമാണ് (അവയെ എന്ത് വിളിക്കുന്നു അല്ലെങ്കിൽ അവ എങ്ങനെ "പെരുമാറുന്നു" എന്നത് പ്രശ്നമല്ല), അത് രചിക്കുന്നതിലൂടെ ഞങ്ങൾ പ്രശ്‌നത്തിന് ഒരു പരിഹാരം നേടുന്നു. കാര്യക്ഷമതയ്ക്കായി, ഈ മൊഡ്യൂളുകൾ വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുന്നത് വളരെ അഭികാമ്യമാണ്. എന്തുവിലകൊടുത്തും ഉപയോഗിക്കാൻ മാത്രമല്ല, ഉപയോഗിക്കാനും സൗകര്യപ്രദമായ രീതിയിൽ. ഇവിടെ മറ്റൊരു അസുഖകരമായ "ആശ്ചര്യം" നമ്മെ കാത്തിരിക്കുന്നു. മിക്ക ഉയർന്ന തലത്തിലുള്ള ഭാഷകളും "പ്രവർത്തനം", "നടപടിക്രമം" തുടങ്ങിയ ഘടനാപരമായ യൂണിറ്റുകൾ ഉപയോഗിച്ചാണ് പ്രവർത്തിക്കുന്നത്. കൂടാതെ, അവരുമായി ഇടപഴകുന്നതിനുള്ള ഒരു മാർഗമായി, "പാസിംഗ് പാരാമീറ്ററുകൾ" ഉപയോഗിക്കുന്നു. ഇത് തികച്ചും യുക്തിസഹമാണ്, ഇവിടെ ചോദ്യങ്ങളൊന്നും ഉയരുന്നില്ല. എന്നാൽ എല്ലായ്പ്പോഴും എന്നപോലെ, "എന്തു ചെയ്തു എന്നതല്ല പ്രധാനം, അത് എങ്ങനെ ചെയ്തു എന്നതാണ്" (സി). ഇവിടെ ഏറ്റവും മനസ്സിലാക്കാൻ കഴിയാത്ത ഭാഗം ആരംഭിക്കുന്നു. ഇന്ന്, പരാമീറ്ററുകളുടെ കൈമാറ്റം സംഘടിപ്പിക്കുന്നതിന് 3 പൊതു വഴികളുണ്ട്: cdecl, stdcall, ഫാസ്റ്റ്കോൾ. അതിനാൽ, ഈ രീതികളൊന്നും x86-ന് "നേറ്റീവ്" അല്ല. മാത്രമല്ല, വിളിക്കപ്പെടുന്ന സബ്റൂട്ടീനുകളുടെ പ്രവർത്തനക്ഷമത വിപുലീകരിക്കുന്നതിന്റെ വീക്ഷണകോണിൽ നിന്ന് അവയെല്ലാം പിഴവുള്ളവയാണ്. അതായത്, പാസാക്കിയ പാരാമീറ്ററുകളുടെ എണ്ണം വർദ്ധിപ്പിക്കുന്നതിലൂടെ, ഈ ഫംഗ്‌ഷന്റെ/സബ്റൂട്ടീന്റെ എല്ലാ കോൾ പോയിന്റുകളും മാറ്റാൻ ഞങ്ങൾ നിർബന്ധിതരാകുന്നു, അല്ലെങ്കിൽ സമാനമായ പ്രവർത്തനക്ഷമതയുള്ള ഒരു പുതിയ സബ്‌റൂട്ടീൻ സൃഷ്‌ടിക്കുന്നു, അതിനെ അല്പം വ്യത്യസ്തമായ രീതിയിൽ വിളിക്കും.

2 വ്യത്യസ്ത സ്റ്റാക്കുകളും (ഒരു ഡാറ്റാ സ്റ്റാക്കും വിലാസം/കൺട്രോൾ സ്റ്റാക്കും) വികസിപ്പിച്ച സ്റ്റാക്ക് മാനിപ്പുലേഷൻ കമാൻഡുകളും (സ്റ്റാക്ക് എലമെന്റുകളിലേക്കുള്ള ഇൻഡെക്സ് ആക്സസ് എങ്കിലും) ഉള്ള പ്രോസസറുകളിൽ പാസിംഗ് പാസിംഗ് രീതികൾ താരതമ്യേന നന്നായി പ്രവർത്തിക്കുന്നു. എന്നാൽ x86-ൽ പ്രോഗ്രാമിംഗ് ചെയ്യുമ്പോൾ, പാരാമീറ്ററുകൾ കടന്നുപോകുമ്പോൾ/സ്വീകരിക്കുമ്പോൾ നിങ്ങൾ ആദ്യം വളച്ചൊടിക്കേണ്ടതുണ്ട്, തുടർന്ന് അവയെ "ഘടനാപരമായി" സ്റ്റാക്കിൽ നിന്ന് നീക്കം ചെയ്യാൻ ഓർമ്മിക്കുക. അതേ സമയം, പരമാവധി സ്റ്റാക്ക് ഡെപ്ത് ഊഹിക്കാൻ / കണക്കാക്കാൻ ശ്രമിക്കുന്നു. x86 (16/32 ബിറ്റ് മോഡ്) ഒരു പ്രോസസറാണെന്ന് നമുക്ക് ഓർക്കാം:

• സ്പെഷ്യലൈസ്ഡ് രജിസ്റ്ററുകൾ (RONs - പൊതു ഉദ്ദേശ്യ രജിസ്റ്ററുകൾ - അത്തരത്തിലുള്ളതല്ല: അതായത്, ഒരു കമാൻഡ് ഉപയോഗിച്ച്, GS രജിസ്റ്ററിലെ ഉള്ളടക്കങ്ങൾ EDI-ൽ നിന്നുള്ള മൂല്യം കൊണ്ട് ഗുണിച്ച് ഫലം EDX: ECX ജോഡിയിൽ നേടാനോ വിഭജിക്കാനോ കഴിയില്ല. EDI:ESI രജിസ്റ്റർ ജോഡിയിൽ നിന്നുള്ള മൂല്യം ഉള്ളടക്ക രജിസ്റ്ററിന്റെ EAX);
• കുറച്ച് രജിസ്റ്ററുകൾ ഉണ്ട്;
• ഒരു സ്റ്റാക്ക്;
• മെമ്മറി ലൊക്കേഷൻ അവിടെ സംഭരിച്ചിരിക്കുന്ന മൂല്യത്തെക്കുറിച്ചുള്ള ഒരു വിവരവും നൽകുന്നില്ല.

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, ഒരു വലിയ രജിസ്റ്റർ ഫയലുള്ള പ്രോസസ്സറുകൾക്കായി ഉപയോഗിക്കുന്ന പ്രോഗ്രാമിംഗ് ടെക്നിക്കുകൾ, ഒന്നിലധികം സ്വതന്ത്ര സ്റ്റാക്കുകൾക്കുള്ള പിന്തുണ മുതലായവ. x86-ൽ പ്രോഗ്രാം ചെയ്യുമ്പോൾ മിക്കവാറും ബാധകമല്ല.

"ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിൽ" എഴുതിയിരിക്കുന്ന റെഡിമെയ്ഡ് മൊഡ്യൂളുകളുമായുള്ള ആശയവിനിമയത്തിന്റെ അടുത്ത സവിശേഷത "വേരിയബിൾ തരങ്ങളുമായുള്ള" "സമരം" ആണ്. ഒരു വശത്ത്, വേരിയബിൾ തരങ്ങൾ പ്രത്യക്ഷപ്പെടാനുള്ള കാരണം വ്യക്തമാണ് - പ്രോഗ്രാമർക്ക് തന്റെ സബ്റൂട്ടീൻ / മൊഡ്യൂളിനുള്ളിൽ എന്ത് മൂല്യങ്ങളാണ് ഉപയോഗിക്കുന്നതെന്ന് അറിയാം. ഇതിനെ അടിസ്ഥാനമാക്കി, ഒരു വേരിയബിളിന്റെ മൂല്യങ്ങളുടെ തരം സജ്ജീകരിക്കുന്നതിലൂടെ, തരം/മൂല്യ പരിധികളുടെ നിയന്ത്രണം ഭാഷാ വിവർത്തകനെ ഏൽപ്പിച്ചുകൊണ്ട് നമുക്ക് ഒരു പ്രോഗ്രാം എഴുതുന്നത് "ലളിതമാക്കാം" എന്നത് തികച്ചും യുക്തിസഹമാണെന്ന് തോന്നുന്നു. എന്നാൽ ഇവിടെയും കുഞ്ഞിനെ കുളിക്കടവിനൊപ്പം പുറത്തേക്ക് വലിച്ചെറിയുകയായിരുന്നു. കാരണം ഏതൊരു പ്രോഗ്രാമും എഴുതിയിരിക്കുന്നത് ഒരു ശൂന്യതയിൽ ഗോളാകൃതിയിലുള്ള കുതിരകളെ സൃഷ്ടിക്കാനല്ല, മറിച്ച് അതിലേക്കാണ് പ്രായോഗിക ജോലിഉപയോക്തൃ ഡാറ്റ ഉപയോഗിച്ച്. അതായത്, സിസ്റ്റം സമീപനത്തിന്റെ വ്യക്തമായ ലംഘനം - ഉയർന്ന തലത്തിലുള്ള ഭാഷകളുടെ ഡെവലപ്പർമാർ പുറം ലോകവുമായുള്ള ഇടപെടൽ കണക്കിലെടുക്കാതെ അവരുടെ സിസ്റ്റങ്ങൾ പരിഗണിക്കുന്നതുപോലെ. തൽഫലമായി, ടൈപ്പ് ചെയ്‌ത ഭാഷയിൽ പ്രോഗ്രാമിംഗ് ചെയ്യുമ്പോൾ, ഡെവലപ്പർ സാധ്യമായ എല്ലാ തരത്തിലുള്ള "തെറ്റായ" ഇൻപുട്ട് ഡാറ്റയും മുൻകൂട്ടി കാണുകയും അനിശ്ചിതത്വങ്ങൾ പരിഹരിക്കാനുള്ള വഴികൾ തേടുകയും വേണം. ഇവിടെയാണ് ഭീകരമായ പിന്തുണാ സംവിധാനങ്ങൾ പ്രവർത്തിക്കുന്നത്. പതിവ് ഭാവങ്ങൾ, പ്രോസസ്സിംഗ് അസാധാരണമായ സാഹചര്യങ്ങൾ, രീതി/നടപടി ഒപ്പുകൾ വത്യസ്ത ഇനങ്ങൾമൂല്യങ്ങളും മറ്റ് തലമുറയിലെ ഊന്നുവടികളും.

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, x86 ആർക്കിടെക്ചറിനായി, മെമ്മറി സെല്ലിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യത്തിന് ഒരു തരവും ഇല്ല. അസംബ്ലർ പ്രോഗ്രാമർക്ക് പ്രത്യേകാവകാശവും ലഭിക്കുന്നു ഉത്തരവാദിത്തംഈ മൂല്യം എങ്ങനെ പ്രോസസ്സ് ചെയ്യണമെന്ന് നിർണ്ണയിക്കുന്നതിന്. ഒരു മൂല്യത്തിന്റെ തരം എങ്ങനെ നിർണ്ണയിക്കാമെന്നും അത് എങ്ങനെ പ്രോസസ്സ് ചെയ്യണം എന്നതിനെക്കുറിച്ചും, തിരഞ്ഞെടുക്കാൻ നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്. പക്ഷേ, നമുക്ക് ഒരിക്കൽ കൂടി ഊന്നിപ്പറയാം, അവയെല്ലാം ഉപയോക്താവിൽ നിന്ന് ലഭിച്ച മൂല്യങ്ങളുമായി മാത്രം ബന്ധപ്പെട്ടിരിക്കുന്നു. ടൈപ്പ് ചെയ്‌ത ഭാഷകളുടെ ഡവലപ്പർമാർ ശരിയായി സൂചിപ്പിച്ചതുപോലെ: ആന്തരിക, സേവന വേരിയബിളുകളുടെ മൂല്യങ്ങളുടെ തരങ്ങൾ എല്ലായ്പ്പോഴും മുൻകൂട്ടി അറിയാം.

ഈ കാരണം (ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിൽ എഴുതിയ മൊഡ്യൂളുകളിലേക്ക് പാരാമീറ്ററുകൾ വികൃതമാക്കുന്നതും ഒരേ മൊഡ്യൂളുകളിലേക്ക് പാസാക്കിയ പാരാമീറ്ററുകളുടെ തരങ്ങൾ കർശനമായി നിരീക്ഷിക്കേണ്ടതിന്റെ ആവശ്യകതയും) അസംബ്ലി ഭാഷയിലെ പ്രോഗ്രാമിംഗ് യുക്തിരഹിതമായി ബുദ്ധിമുട്ടാക്കാനുള്ള പ്രധാന കാരണമായി തോന്നുന്നു. മറ്റുള്ളവർ ഇതിനകം വികസിപ്പിച്ചെടുത്ത കാര്യങ്ങൾ പ്രയോജനപ്പെടുത്തുന്നതിന്, കഷ്ടപ്പെടുന്നതിനുപകരം, അവർ ചെയ്യാത്തത് ശരിയാക്കാൻ അതേ “സ്റ്റാൻഡേർഡ്” ക്രച്ചസ് തിരുകാൻ ഭൂരിപക്ഷം പേരും “ഉയർന്ന തലത്തിലുള്ള ഭാഷകളുടെ” കാടിനെ മനസ്സിലാക്കാൻ ഇഷ്ടപ്പെടുന്നു. ഈ ദിനചര്യയിൽ നിന്ന് പ്രോഗ്രാമറെ എങ്ങനെയെങ്കിലും "ആശ്വാസം" നൽകുന്ന ഒരു അപൂർവ അസംബ്ലർ വിവർത്തകനാണ് ഇത്.

എന്തുചെയ്യും?

15 വർഷം കണക്കിലെടുത്താണ് പ്രാഥമിക നിഗമനം ബ്രേക്ക്അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിൽ.
ഒന്നാമതായി, മൊഡ്യൂളുകൾ അല്ലെങ്കിൽ പ്രോഗ്രാമിന്റെ ഭാഗങ്ങൾ സംബന്ധിച്ച്. പൊതുവേ, ഒരു പ്രോഗ്രാമിന്റെ രണ്ട് തരം എക്സിക്യൂട്ടീവ് മൊഡ്യൂളുകൾ അസംബ്ലി ഭാഷയിൽ വേർതിരിക്കുന്നത് മൂല്യവത്താണ് - "ഓപ്പറേഷൻ", "സബ്റൂട്ടീൻ".

• "ഓപ്പറേഷൻ" എന്നത് ഒരു "ആറ്റോമിക്" പ്രവർത്തനം നടത്തുന്ന ഒരു മൊഡ്യൂളാണ്, മാത്രമല്ല അതിന്റെ നിർവ്വഹണത്തിന് നിരവധി പാരാമീറ്ററുകൾ ആവശ്യമില്ല (ഉദാഹരണത്തിന്, മുഴുവൻ സ്‌ക്രീനും മായ്‌ക്കുന്ന പ്രവർത്തനം അല്ലെങ്കിൽ മീഡിയൻ കണക്കാക്കുന്നതിനുള്ള പ്രവർത്തനം സംഖ്യ പരമ്പരഇത്യാദി.).
• ശരിയായ പ്രവർത്തനത്തിന് നിരവധി ഇൻപുട്ട് പാരാമീറ്ററുകൾ (2x-3x-ൽ കൂടുതൽ) ആവശ്യമുള്ള ഒരു ഫങ്ഷണൽ മൊഡ്യൂളിനെ "സബ്റൂട്ടീൻ" എന്ന് വിളിക്കണം.

ഇവിടെ അനിവാര്യമായ അനുഭവം വിലയിരുത്തുന്നത് മൂല്യവത്താണ് പ്രവർത്തനപരമായ ഭാഷകൾ. അവർ ഞങ്ങൾക്ക് ഉപയോഗിക്കേണ്ട മൂല്യവത്തായ 2 ടൂളുകൾ നൽകി: "ഡാറ്റ ഘടന" (അല്ലെങ്കിൽ, REXX ഒരു ഉദാഹരണമായി ഉപയോഗിക്കുന്നു, കോമ്പൗണ്ട്/ഓഗ്മെന്റബിൾ വേരിയബിളുകൾ) "ഡാറ്റ നോൺ-മ്യൂട്ടബിലിറ്റി".

നോൺ-മ്യൂട്ടബിലിറ്റിയുടെ നിയമം പിന്തുടരുന്നതും ഉപയോഗപ്രദമാണ് - അതായത്, പാസാക്കിയ പാരാമീറ്ററുകളുടെ മാറ്റമില്ലായ്മ. സബ്റൂട്ടീന് അതിലേക്ക് കൈമാറിയ ഘടനയിലെ മൂല്യങ്ങൾ മാറ്റാൻ കഴിയില്ല (അരുത്), ഫലം രജിസ്റ്ററുകളിൽ (2-3 പാരാമീറ്ററുകളിൽ കൂടരുത്) അല്ലെങ്കിൽ സൃഷ്ടിക്കുന്ന ഒരു പുതിയ ഘടനയിലും നൽകും. അങ്ങനെ, സബ്റൂട്ടീനുകൾ വഴി "മറന്നുപോയ" ഡാറ്റാ മാറ്റങ്ങളുടെ കാര്യത്തിൽ ഘടനകളുടെ പകർപ്പുകൾ നിർമ്മിക്കേണ്ടതിന്റെ ആവശ്യകതയിൽ നിന്ന് ഞങ്ങൾ മോചിതരാകുന്നു, കൂടാതെ ഒരേ/സമാനമായ പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന നിരവധി സബ്റൂട്ടീനുകളെ വിളിക്കാൻ ഇതിനകം സൃഷ്ടിച്ച ഘടന പൂർണ്ണമായും അല്ലെങ്കിൽ അതിന്റെ പ്രധാന ഭാഗവും ഉപയോഗിക്കാം. . മാത്രമല്ല, മിക്കവാറും യാന്ത്രികമായി ഞങ്ങൾ അടുത്ത “ഫങ്ഷണൽ” റൂളിൽ എത്തിച്ചേരുന്നു - സബ്റൂട്ടീനുകളുടെയും പ്രവർത്തനങ്ങളുടെയും ആന്തരിക സന്ദർഭ-സ്വാതന്ത്ര്യം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അവയുടെ പ്രോസസ്സിംഗിന്റെ രീതി/സബ്റൂട്ടീനിൽ നിന്ന് സ്റ്റേറ്റ്/ഡാറ്റയെ വേർതിരിക്കുന്നത് (ഓട്ടോമാറ്റൺ മോഡലിന് വിരുദ്ധമായി). കേസുകളിൽ സമാന്തര പ്രോഗ്രാമിംഗ്, ഒപ്പം പങ്കുവയ്ക്കുന്നുഒരു സബ്റൂട്ടീൻ ഉപയോഗിച്ച്, ഒന്നിലധികം നിർവ്വഹണ സന്ദർഭങ്ങൾ സൃഷ്ടിക്കേണ്ടതിന്റെ ആവശ്യകതയും അവയുടെ "നോൺ-ഇന്റർസെക്ഷൻ" നിരീക്ഷിക്കേണ്ടതും നിരവധി കോളുകളുടെ കാര്യത്തിൽ വ്യത്യസ്ത "സ്റ്റേറ്റുകൾ" ഉള്ള ഒരു സബ്റൂട്ടീന്റെ ഒന്നിലധികം സന്ദർഭങ്ങൾ സൃഷ്ടിക്കുന്നതും ഞങ്ങൾ ഒഴിവാക്കുന്നു.

ഡാറ്റയുടെ “തരങ്ങളെ” സംബന്ധിച്ചിടത്തോളം, ഇവിടെ നിങ്ങൾക്ക് “എല്ലാം ഉള്ളതുപോലെ” ഉപേക്ഷിക്കാം, അല്ലെങ്കിൽ നിങ്ങൾക്ക് ചക്രം പുനർനിർമ്മിക്കാനും നിർബന്ധിത ഭാഷാ വിവർത്തകരുടെ ഡെവലപ്പർമാർ ദീർഘകാലമായി ഉപയോഗിച്ചത് ഉപയോഗിക്കാനും കഴിയില്ല - “മൂല്യം തരം ഐഡന്റിഫയർ”. അതായത്, എല്ലാ ഡാറ്റയും വരുന്നു പുറം ലോകംവിശകലനം ചെയ്യുകയും ഫലമായുണ്ടാകുന്ന ഓരോ മൂല്യവും പ്രോസസ്സ് ചെയ്യുന്ന തരത്തിന്റെയും (പൂർണ്ണസംഖ്യ, ഫ്ലോട്ട്, പാക്ക് ചെയ്ത BCD, പ്രതീക കോഡ് മുതലായവ) ഫീൽഡിന്റെ/മൂല്യത്തിന്റെ വലുപ്പത്തിന്റെയും ഒരു ഐഡന്റിഫയർ അസൈൻ ചെയ്യുന്നു. ഈ വിവരങ്ങൾ ഉള്ളതിനാൽ, പ്രോഗ്രാമർ, ഒരു വശത്ത്, മൂല്യങ്ങൾ നൽകുന്നതിനുള്ള “നിയമങ്ങളുടെ” അനാവശ്യമായ ഇടുങ്ങിയ ചട്ടക്കൂടിലേക്ക് ഉപയോക്താവിനെ നിർബന്ധിക്കുന്നില്ല, മറുവശത്ത്, ഉപയോക്താവിന്റെ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള ഏറ്റവും ഫലപ്രദമായ മാർഗം തിരഞ്ഞെടുക്കാനുള്ള അവസരമുണ്ട്. ജോലി പ്രക്രിയയിൽ. പക്ഷേ, ഞാൻ ഒരിക്കൽ കൂടി ആവർത്തിക്കുന്നു, ഇത് ഉപയോക്തൃ ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിന് മാത്രമേ ബാധകമാകൂ.

ഇവയായിരുന്നു പൊതുവായ പരിഗണനകൾഅസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിനെക്കുറിച്ച്, ഡിസൈൻ, ഡീബഗ്ഗിംഗ്, പിശക് കൈകാര്യം ചെയ്യൽ പ്രശ്നങ്ങൾ എന്നിവയുമായി ബന്ധപ്പെട്ടതല്ല. ആദ്യം മുതൽ അവ എഴുതുന്ന OS ഡവലപ്പർമാർക്ക് (അതിലും കൂടുതലായി അസംബ്ലറിൽ) ചിന്തിക്കാൻ എന്തെങ്കിലും ഉണ്ടായിരിക്കുമെന്നും അസംബ്ലറിലെ പ്രോഗ്രാമിംഗ് കൂടുതൽ ചിട്ടയായതും സൗകര്യപ്രദവുമാക്കുന്നതിനുള്ള വഴികൾ അവർ തിരഞ്ഞെടുക്കുമെന്നും ഞാൻ പ്രതീക്ഷിക്കുന്നു. ആസ്വാദ്യകരവും, അവർ മറ്റുള്ളവരുടെ, പലപ്പോഴും നിരാശാജനകമായ "വക്രമായ" ഓപ്ഷനുകൾ അന്ധമായി പകർത്തുകയില്ല.

ഇന്ന് ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷകളുടെ ഒരു വലിയ എണ്ണം ഉണ്ട്. അവരുടെ പശ്ചാത്തലത്തിൽ, പ്രോഗ്രാമിംഗ് ഇൻ താഴ്ന്ന നിലവാരത്തിലുള്ള ഭാഷ- അസംബ്ലർ - ഒറ്റനോട്ടത്തിൽ കാലഹരണപ്പെട്ടതും യുക്തിരഹിതവുമായ ഒന്നായി തോന്നാം. എന്നിരുന്നാലും, അത് മാത്രം തോന്നുന്നു. അസംബ്ലർ യഥാർത്ഥത്തിൽ ഒരു പ്രോസസ്സർ ഭാഷയാണെന്ന് തിരിച്ചറിയണം, അതിനർത്ഥം പ്രോസസ്സറുകൾ ഉള്ളിടത്തോളം ഇത് കൂടാതെ അത് ചെയ്യാൻ കഴിയില്ല എന്നാണ്. അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിന്റെ പ്രധാന ഗുണങ്ങൾ ഇവയാണ് പരമാവധി പ്രകടനംസ്വീകരിച്ച പ്രോഗ്രാമുകളുടെ ഏറ്റവും കുറഞ്ഞ വലുപ്പവും.

പോരായ്മകൾ പലപ്പോഴും ചായ്‌വ് കൊണ്ട് മാത്രമാണ് ആധുനിക വിപണിഗുണനിലവാരത്തേക്കാൾ അളവ് മുൻഗണന നൽകാൻ. ആധുനിക കമ്പ്യൂട്ടറുകൾഉയർന്ന തലത്തിലുള്ള ഫംഗ്‌ഷനുകളുടെ ഒരു കൂട്ടം കമാൻഡുകളെ എളുപ്പത്തിൽ നേരിടാൻ കഴിയും, ഇത് എളുപ്പമല്ലെങ്കിൽ, നിങ്ങളുടെ മെഷീന്റെ ഹാർഡ്‌വെയർ അപ്‌ഡേറ്റ് ചെയ്യുക! വാണിജ്യ പ്രോഗ്രാമിംഗിന്റെ നിയമമാണിത്. എങ്കിൽ ഞങ്ങൾ സംസാരിക്കുന്നത്ആത്മാവിനു വേണ്ടിയുള്ള പ്രോഗ്രാമിംഗിനെക്കുറിച്ച്, അസംബ്ലി ഭാഷയിൽ എഴുതിയ ഒതുക്കമുള്ളതും വേഗതയേറിയതുമായ ഒരു പ്രോഗ്രാം അനാവശ്യ പ്രവർത്തനങ്ങളുടെ ഒരു കൂട്ടം ഭാരമുള്ള ഒരു ഉയർന്ന തലത്തിലുള്ള ഹൾക്കിനെക്കാൾ വളരെ മനോഹരമായ മതിപ്പുണ്ടാക്കും. തിരഞ്ഞെടുത്ത ചിലർക്ക് മാത്രമേ അസംബ്ലറിൽ പ്രോഗ്രാം ചെയ്യാൻ കഴിയൂ എന്ന അഭിപ്രായമുണ്ട്. ഇത് സത്യമല്ല. തീർച്ചയായും, കഴിവുള്ള അസംബ്ലർ പ്രോഗ്രാമർമാരെ ഒരു വശത്ത് കണക്കാക്കാം, എന്നാൽ മനുഷ്യ പ്രവർത്തനത്തിന്റെ ഏത് മേഖലയിലും ഇതാണ് സ്ഥിതി. ഏയ്‌സ് ഡ്രൈവർമാർ അധികമില്ല, പക്ഷേ ആഗ്രഹമുണ്ടെങ്കിൽ ആർക്കും കാർ ഓടിക്കാൻ പഠിക്കാം. ഈ ലേഖന പരമ്പര വായിച്ചുകഴിഞ്ഞാൽ, നിങ്ങൾ ഒരു ഹാക്കർ ആകില്ല. എന്നിരുന്നാലും നിങ്ങൾക്ക് ലഭിക്കും പൊതുവിവരംപഠിക്കുകയും ചെയ്യുക ലളിതമായ വഴികൾവിൻഡോസിനായുള്ള അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗ്, അതിന്റെ ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകളും കമ്പൈലർ മാക്രോ നിർദ്ദേശങ്ങളും ഉപയോഗിക്കുന്നു. സ്വാഭാവികമായും, വിൻഡോസ് പ്രോഗ്രാമിംഗിൽ വൈദഗ്ദ്ധ്യം നേടുന്നതിന്, നിങ്ങൾക്ക് വിൻഡോസ് കഴിവുകളും അനുഭവപരിചയവും ആവശ്യമാണ്. ആദ്യം നിങ്ങൾക്ക് കൂടുതൽ മനസ്സിലാകില്ല, എന്നാൽ ഇതിൽ അസ്വസ്ഥരാകരുത്, തുടർന്ന് വായിക്കുക: കാലക്രമേണ, എല്ലാം ശരിയായിരിക്കും.

അതിനാൽ, പ്രോഗ്രാമിംഗ് ആരംഭിക്കുന്നതിന്, ഞങ്ങൾക്ക് കുറഞ്ഞത് ഒരു കമ്പൈലർ ആവശ്യമാണ്. ഒരു പ്രോഗ്രാമർ എഴുതിയ സോഴ്സ് കോഡിനെ പ്രോസസർ എക്സിക്യൂട്ട് ചെയ്യാവുന്ന ഒന്നിലേക്ക് വിവർത്തനം ചെയ്യുന്ന ഒരു പ്രോഗ്രാമാണ് കംപൈലർ. മെഷീൻ കോഡ്. മിക്ക അസംബ്ലർ പാഠപുസ്തകങ്ങളും MASM32 (Microsoft Macro Assembler) പാക്കേജ് ഉപയോഗിക്കുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. എന്നാൽ വൈവിധ്യത്തിന്റെ ഒരു രൂപമെന്ന നിലയിലും മറ്റ് പല കാരണങ്ങളാലും, അതിവേഗം ജനപ്രീതി നേടിയുകൊണ്ടിരിക്കുന്ന യുവ കമ്പൈലറായ FASM (ഫ്ലാറ്റ് അസംബ്ലർ) ഞാൻ നിങ്ങളെ പരിചയപ്പെടുത്തും. ഈ കംപൈലർ ഇൻസ്റ്റാൾ ചെയ്യാനും ഉപയോഗിക്കാനും വളരെ എളുപ്പമാണ്, ഒതുക്കമുള്ളതും വേഗതയുള്ളതുമാണ്, സമ്പന്നവും ശേഷിയുള്ളതുമായ മാക്രോ വാക്യഘടനയുണ്ട്, അത് പലതും ഓട്ടോമേറ്റ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു. പതിവ് ജോലികൾ. അദ്ദേഹത്തിന്റെ പുതിയ പതിപ്പ്ഫ്ലാറ്റ് അസംബ്ലർ തിരഞ്ഞെടുത്ത് നിങ്ങൾക്ക് ഇവിടെ നിന്ന് ഡൗൺലോഡ് ചെയ്യാം: വെബ്സൈറ്റ് വിൻഡോസിനായി. FASM ഇൻസ്റ്റാൾ ചെയ്യാൻ, ഒരു ഫോൾഡർ സൃഷ്‌ടിക്കുക, ഉദാഹരണത്തിന്, "D:\FASM", ഡൗൺലോഡ് ചെയ്‌ത zip ആർക്കൈവിന്റെ ഉള്ളടക്കങ്ങൾ അതിലേക്ക് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യുക. ഒന്നും മാറ്റാതെ FASMW.EXE പ്രവർത്തിപ്പിച്ച് അടയ്ക്കുക. വഴിയിൽ, നിങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ സാധാരണ കണ്ടക്ടർ, കൂടാതെ ഫയൽ എക്സ്റ്റൻഷൻ (ഉദാഹരണത്തിന്, .EXE) പ്രദർശിപ്പിക്കപ്പെടുന്നില്ല, ടൂളുകൾ -> ഫോൾഡർ ഓപ്ഷനുകൾ -> റജിസ്റ്റർ ചെയ്ത ഫയൽ തരങ്ങൾക്കായുള്ള വിപുലീകരണങ്ങൾ കാണാനും അൺചെക്ക് ചെയ്യാനും റൺ ചെയ്യാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു. കമ്പൈലറിന്റെ ആദ്യ സമാരംഭത്തിനു ശേഷം, ഒരു കോൺഫിഗറേഷൻ ഫയൽ ഞങ്ങളുടെ ഫോൾഡറിൽ ദൃശ്യമാകും - FASMW.INI. ഒരു സാധാരണ നോട്ട്പാഡ് ഉപയോഗിച്ച് ഇത് തുറന്ന് ഏറ്റവും താഴെ 3 വരികൾ ചേർക്കുക:

Fasminc=D:\FASM\INCLUDE
ഉൾപ്പെടുത്തുക=D:\FASM\INCLUDE

നിങ്ങൾ മറ്റൊരു ലൊക്കേഷനിലേക്ക് FASM അൺപാക്ക് ചെയ്യുകയാണെങ്കിൽ, നിങ്ങളുടെ പാത്ത് ഉപയോഗിച്ച് "D:\FASM\" മാറ്റിസ്ഥാപിക്കുക. FASMW.INI സംരക്ഷിച്ച് അടയ്ക്കുക. മുന്നോട്ട് നോക്കുമ്പോൾ, ഞങ്ങൾ കംപൈലർ എങ്ങനെ ഉപയോഗിക്കുമെന്ന് ഞാൻ ചുരുക്കമായി വിശദീകരിക്കും:
1. ഞങ്ങൾ പ്രോഗ്രാം ടെക്സ്റ്റ് എഴുതുന്നു, അല്ലെങ്കിൽ .asm ഫയലിൽ സംരക്ഷിച്ച മുമ്പ് എഴുതിയ ടെക്സ്റ്റ് തുറക്കുക, അല്ലെങ്കിൽ ഒരു കോമ്പിനേഷൻ ഉപയോഗിച്ച് ക്ലിപ്പ്ബോർഡിൽ നിന്ന് പ്രോഗ്രാം ടെക്സ്റ്റ് ഒട്ടിക്കുക.
2. പ്രോഗ്രാം കംപൈൽ ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനും F9 അമർത്തുക, അല്ലെങ്കിൽ കംപൈൽ ചെയ്യാൻ Ctrl+F9 അമർത്തുക. പ്രോഗ്രാം ടെക്സ്റ്റ് ഇതുവരെ സംരക്ഷിച്ചിട്ടില്ലെങ്കിൽ, കംപൈൽ ചെയ്യുന്നതിന് മുമ്പ് അത് സംരക്ഷിക്കാൻ കംപൈലർ നിങ്ങളോട് ആവശ്യപ്പെടും.
3. പ്രോഗ്രാം ആരംഭിക്കുകയാണെങ്കിൽ, ശരിയായ പ്രവർത്തനത്തിനായി ഞങ്ങൾ അത് പരിശോധിക്കുന്നു, ഇല്ലെങ്കിൽ, ഞങ്ങൾ പിശകുകൾക്കായി നോക്കുന്നു, അതിൽ ഏറ്റവും ഗുരുതരമായത് കംപൈലർ നമ്മെ ചൂണ്ടിക്കാണിക്കുകയോ സൂക്ഷ്മമായി സൂചന നൽകുകയോ ചെയ്യും.
ശരി, ഇപ്പോൾ നമുക്ക് ദീർഘകാലമായി കാത്തിരുന്ന പരിശീലനം ആരംഭിക്കാം. ഞങ്ങൾ ഞങ്ങളുടെ FASMW.EXE സമാരംഭിച്ച് അതിൽ ഞങ്ങളുടെ ആദ്യ പ്രോഗ്രാമിന്റെ കോഡ് ടൈപ്പ് ചെയ്യുക:

"%fasminc%/win32ax.inc" ഉൾപ്പെടുത്തുക

ഡാറ്റ
അടിക്കുറിപ്പ് db "എന്റെ ആദ്യ പ്രോഗ്രാം.",0
db "എല്ലാവർക്കും ഹലോ!",0 എന്ന് ടെക്‌സ്‌റ്റ് ചെയ്യുക

കോഡ്
ആരംഭിക്കുക:

എക്സിറ്റ്പ്രോസസ്,0 അഭ്യർത്ഥിക്കുക

കീബോർഡിലെ Run -> Run അല്ലെങ്കിൽ F9 ക്ലിക്ക് ചെയ്യുക. സേവ് വിൻഡോയിൽ, സംരക്ഷിക്കുന്നതിനുള്ള ഫയലിന്റെ പേരും ഫോൾഡറും വ്യക്തമാക്കുക. ഓരോ പ്രോഗ്രാമും സേവ് ചെയ്യുന്നത് ശീലമാക്കുന്നത് നല്ലതാണ് പ്രത്യേക ഫോൾഡർ, ഭാവിയിൽ ആശയക്കുഴപ്പത്തിലാകാതിരിക്കാൻ, ഓരോ പ്രോഗ്രാമിലും ഒരു കൂട്ടം ഫയലുകൾ അടങ്ങിയിരിക്കുമ്പോൾ: ചിത്രങ്ങൾ, ഐക്കണുകൾ, സംഗീതം മുതലായവ. കംപൈലർ ഒരു പിശക് സൃഷ്ടിക്കുകയാണെങ്കിൽ, അത് വ്യക്തമാക്കിയ ലൈൻ ശ്രദ്ധാപൂർവ്വം രണ്ടുതവണ പരിശോധിക്കുക - നിങ്ങൾക്ക് ഒരു കോമയോ സ്‌പെയ്‌സോ നഷ്‌ടമായിരിക്കാം. കംപൈലർ കേസ് സെൻസിറ്റീവ് ആണെന്നും നിങ്ങൾ അറിയേണ്ടതുണ്ട്, അതിനാൽ .ഡാറ്റയും .ഡാറ്റയും രണ്ടായി കണക്കാക്കുന്നു വ്യത്യസ്ത നിർദ്ദേശങ്ങൾ. നിങ്ങൾ എല്ലാം ശരിയായി ചെയ്തുവെങ്കിൽ, ഫലം ഒരു ലളിതമായ മെസേജ് ബോക്സ് ആയിരിക്കും (ചിത്രം 1). പ്രോഗ്രാം വാചകത്തിൽ ഞങ്ങൾ എന്താണ് എഴുതിയതെന്ന് ഇപ്പോൾ നമുക്ക് കണ്ടെത്താം. ആദ്യ വരിയിൽ, ഉൾപ്പെടുത്തിയ നിർദ്ദേശങ്ങൾക്കൊപ്പം, ഞങ്ങളുടെ പ്രോഗ്രാമിലേക്ക് നിരവധി ഫയലുകളിൽ നിന്നുള്ള വലിയ വാചകം ഞങ്ങൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഓർക്കുക, ഇൻസ്റ്റലേഷൻ സമയത്ത് ഞങ്ങൾ FASMO ini-file-ൽ 3 വരികൾ എഴുതി? ഇപ്പോൾ പ്രോഗ്രാം വാചകത്തിലെ %fasminc% അർത്ഥമാക്കുന്നത് D:\FASM\INCLUDE അല്ലെങ്കിൽ നിങ്ങൾ വ്യക്തമാക്കിയ പാത എന്നാണ്. ഉൾപ്പെടുത്തിയ നിർദ്ദേശം ഉൾപ്പെടുത്തിയതായി തോന്നുന്നു നിർദ്ദിഷ്ട സ്ഥലംമറ്റൊരു ഫയലിൽ നിന്നുള്ള വാചകം. നോട്ട്പാഡ് ഉപയോഗിച്ചോ FASMA-യിലോ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഫോൾഡറിൽ WIN32AX.INC ഫയൽ തുറന്ന്, മനസ്സിലാക്കാൻ കഴിയാത്ത (ഇതിനായി) win32a.inc, macro/if.inc എന്നിവയിൽ നിന്നുള്ള ടെക്‌സ്‌റ്റും ഞങ്ങൾ സ്വയമേവ ഞങ്ങളുടെ പ്രോഗ്രാമിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട് (അറ്റാച്ച് ചെയ്‌തിരിക്കുന്നു) എന്ന് ഉറപ്പാക്കുക. ഇപ്പോൾ) മാക്രോ നിർദ്ദേശങ്ങളും വിൻഡോസ് ഫംഗ്‌ഷൻ ലൈബ്രറികളുടെ ഒരു സാധാരണ സെറ്റും. അതാകട്ടെ, ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഓരോ ഫയലുകളിലും കൂടുതൽ ഉൾപ്പെടുത്തിയ ഫയലുകൾ അടങ്ങിയിരിക്കാം, കൂടാതെ ഈ ശൃംഖലയ്ക്ക് ചക്രവാളത്തിനപ്പുറത്തേക്ക് പോകാനും കഴിയും. ഉൾപ്പെടുത്തിയ ഫയലുകൾ ഉപയോഗിച്ച്, ഞങ്ങൾ ഒരുതരം ഉയർന്ന തലത്തിലുള്ള ഭാഷ സംഘടിപ്പിക്കുന്നു: ഓരോ ഫംഗ്ഷനും സ്വമേധയാ വിവരിക്കുന്ന പതിവ് ഒഴിവാക്കാൻ, ഞങ്ങൾ മുഴുവൻ വിവരണ ലൈബ്രറികളും ഉൾപ്പെടുത്തുന്നു സ്റ്റാൻഡേർഡ് സവിശേഷതകൾവിൻഡോസ്. ഇത്രയും ചെറിയ പരിപാടിക്ക് ഇതൊക്കെ ശരിക്കും ആവശ്യമാണോ? ഇല്ല, ഇത് "എല്ലാ അവസരങ്ങൾക്കുമുള്ള മാന്യൻമാരുടെ സെറ്റ്" പോലെയാണ്. യഥാർത്ഥ ഹാക്കർമാർ, തീർച്ചയായും, എല്ലാം ബന്ധിപ്പിക്കരുത്, പക്ഷേ ഞങ്ങൾ പഠിക്കുകയാണ്, അതിനാൽ ഇത് ആദ്യമായി ചെയ്യുന്നത് ഞങ്ങൾക്ക് ക്ഷമിക്കാവുന്നതാണ്.

അടുത്തതായി നമുക്ക് നിയുക്ത ഡാറ്റ വിഭാഗം ഉണ്ട് - .data. ഈ വിഭാഗത്തിൽ ഞങ്ങൾ രണ്ട് വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്നു - അടിക്കുറിപ്പും വാചകവും. ഇവ പ്രത്യേക കമാൻഡുകളല്ല, അതിനാൽ അവയുടെ പേരുകൾ നിങ്ങൾ ആഗ്രഹിക്കുന്നതുപോലെ മാറ്റാവുന്നതാണ്, എ, ബി എന്നിവപോലും, സ്പേസുകളില്ലാത്തതും റഷ്യൻ ഭാഷയിൽ അല്ലാത്തതുമായിടത്തോളം. ശരി, നിങ്ങൾക്ക് വേരിയബിളുകൾക്ക് പേരിടാൻ കഴിയില്ല സംവരണം ചെയ്ത വാക്കുകൾ, ഉദാഹരണത്തിന്, കോഡ് അല്ലെങ്കിൽ ഡാറ്റ, എന്നാൽ നിങ്ങൾക്ക് കോഡ്_ അല്ലെങ്കിൽ ഡാറ്റ1 ഉപയോഗിക്കാം. db കമാൻഡിന്റെ അർത്ഥം "ബൈറ്റ് നിർവചിക്കുക" എന്നാണ്. തീർച്ചയായും, ഈ വാചകങ്ങളെല്ലാം ഒരു ബൈറ്റിലേക്ക് ചേരില്ല, കാരണം ഓരോ പ്രതീകവും ഒരു മുഴുവൻ ബൈറ്റും എടുക്കുന്നു. എന്നാൽ ഈ സാഹചര്യത്തിൽ, ഈ കമാൻഡ് ഉപയോഗിച്ച് നമ്മൾ ഒരു പോയിന്റർ വേരിയബിൾ മാത്രം നിർവ്വചിക്കുന്നു. സ്ട്രിംഗിന്റെ ആദ്യ പ്രതീകം സംഭരിച്ചിരിക്കുന്ന വിലാസം അതിൽ അടങ്ങിയിരിക്കും. വരിയുടെ വാചകം ഉദ്ധരണി ചിഹ്നങ്ങളിൽ സൂചിപ്പിച്ചിരിക്കുന്നു, കൂടാതെ ഉദ്ധരണി ചിഹ്നങ്ങളിൽ നിങ്ങൾക്ക് ഓപ്ഷണലായി "അത്തരം", "അത്തരം" എന്നിവ ഇടാം - ആരംഭ ഉദ്ധരണി ചിഹ്നം അവസാനിക്കുന്ന ഒന്നിന് തുല്യമായിരിക്കുന്നിടത്തോളം. കോമയ്ക്ക് ശേഷമുള്ള പൂജ്യം സ്ട്രിംഗിന്റെ അവസാനത്തിൽ ഒരു സീറോ ബൈറ്റ് ചേർക്കുന്നു, ഇത് സ്ട്രിംഗിന്റെ അവസാനത്തെ സൂചിപ്പിക്കുന്നു (നൾ-ടെർമിനേറ്റർ). ആദ്യ വരിയിലെ കോമയ്‌ക്കൊപ്പം ഈ പൂജ്യം നീക്കം ചെയ്യാൻ ശ്രമിക്കുക, നിങ്ങൾക്ക് എന്താണ് ലഭിക്കുന്നതെന്ന് കാണുക. ഈ പ്രത്യേക ഉദാഹരണത്തിലെ രണ്ടാമത്തെ വരിയിൽ, നിങ്ങൾക്ക് പൂജ്യം ഇല്ലാതെ ചെയ്യാൻ കഴിയും (കോമയ്‌ക്കൊപ്പം ഇത് നീക്കംചെയ്യുക - അല്ലാത്തപക്ഷം കംപൈലർ ഒരു പിശക് സൂചിപ്പിക്കും), പക്ഷേ ഇത് മാത്രമേ പ്രവർത്തിക്കൂ, കാരണം ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, അടുത്ത വിഭാഗം രണ്ടാമത്തേതിന് തൊട്ടുപിന്നാലെ ആരംഭിക്കുന്നു. ലൈൻ, അത് ആരംഭിക്കുന്നതിന് മുമ്പ്, കംപൈലർ മുമ്പത്തെ വിഭാഗത്തെ വിന്യസിക്കുന്ന പൂജ്യങ്ങളുടെ ഒരു കൂട്ടം സ്വയമേവ നൽകും. പൊതുവേ, അവസാനം പൂജ്യങ്ങൾ ടെക്സ്റ്റ് സ്ട്രിംഗുകൾആവശ്യമാണ്! അടുത്ത വിഭാഗം - വിഭാഗം എക്സിക്യൂട്ടബിൾ കോഡ്പ്രോഗ്രാമുകൾ - .കോഡ്. വിഭാഗത്തിന്റെ തുടക്കത്തിൽ ഒരു ആരംഭം ഉണ്ട്: ലേബൽ. ഈ ഘട്ടത്തിൽ നിന്നാണ് ഞങ്ങളുടെ പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നത് എന്നാണ് ഇതിനർത്ഥം. ആദ്യത്തെ കമാൻഡ് ഇൻവോക്ക് മാക്രോ ഇൻസ്ട്രക്ഷൻ ആണ്. ഇത് അന്തർനിർമ്മിത വിൻഡോസ് API ഫംഗ്‌ഷനെ MessageBox എന്ന് വിളിക്കുന്നു. API ഫംഗ്ഷനുകൾ (അപ്ലിക്കേഷൻ പ്രോഗ്രാമിംഗ് ഇന്റർഫേസ്) ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിലെ ജോലിയെ ഗണ്യമായി ലളിതമാക്കുന്നു. ചില സ്റ്റാൻഡേർഡ് പ്രവർത്തനം നടത്താൻ ഞങ്ങൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തോട് ആവശ്യപ്പെടുന്നത് പോലെയാണ് ഇത്, അത് നിർവ്വഹിക്കുകയും പൂർത്തിയാകുമ്പോൾ ചെയ്ത ജോലിയുടെ ഫലം ഞങ്ങൾക്ക് തിരികെ നൽകുകയും ചെയ്യുന്നു. ഫംഗ്‌ഷൻ നാമത്തിന് ശേഷം അതിന്റെ പാരാമീറ്ററുകൾ കോമകളാൽ വേർതിരിച്ചിരിക്കുന്നു. MessageBox ഫംഗ്‌ഷന് ഇനിപ്പറയുന്ന പാരാമീറ്ററുകൾ ഉണ്ട്:

ആദ്യ പാരാമീറ്ററിൽ ഉടമ വിൻഡോയുടെ ഹാൻഡിൽ ഉണ്ടായിരിക്കണം. ഹാൻഡിൽ ഇതുപോലെയാണ് വ്യക്തിഗത നമ്പർ, പുറപ്പെടുവിക്കുന്നത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റംഓരോ വസ്തുവും (പ്രക്രിയ, വിൻഡോ മുതലായവ). ഞങ്ങളുടെ ഉദാഹരണത്തിലെ 0 അർത്ഥമാക്കുന്നത് ജാലകത്തിന് ഒരു ഉടമ ഇല്ല, അത് സ്വന്തമാണ്, മറ്റേതെങ്കിലും വിൻഡോകളെ ആശ്രയിക്കുന്നില്ല എന്നാണ്.
മുകളിൽ സൂചിപ്പിച്ച നൾ ടെർമിനേറ്ററിൽ അവസാനിക്കുന്ന സന്ദേശ വാചകത്തിന്റെ ആദ്യ അക്ഷരത്തിന്റെ വിലാസത്തിലേക്കുള്ള ഒരു പോയിന്ററാണ് രണ്ടാമത്തെ പാരാമീറ്റർ. ഇതൊരു വിലാസം മാത്രമാണെന്ന് വ്യക്തമായി മനസ്സിലാക്കാൻ, ഫംഗ്‌ഷൻ കോളിൽ നേരിട്ട് ഈ വിലാസം 2 ബൈറ്റുകളായി മാറ്റാം: MessageBox,0,Text+2,Caption,MB_OK അഭ്യർത്ഥിക്കുക, ഇപ്പോൾ ടെക്‌സ്‌റ്റ് ആദ്യത്തെ രണ്ട് അക്ഷരങ്ങളില്ലാതെ പ്രദർശിപ്പിക്കപ്പെടുമെന്ന് ഉറപ്പാക്കുക. .
3rd - സന്ദേശ തലക്കെട്ടിന്റെ ആദ്യ അക്ഷരത്തിന്റെ വിലാസ സൂചകം.
നാലാമത്തെ - സന്ദേശ ശൈലി. നിങ്ങൾക്ക് ഈ ശൈലികളുടെ ഒരു ലിസ്റ്റ് കണ്ടെത്താം, ഉദാഹരണത്തിന്, INCLUDE\EQUATES\USER32.INC. ഇത് ചെയ്യുന്നതിന്, MB_OK എന്നതും ബാക്കിയുള്ളവയും വേഗത്തിൽ കണ്ടെത്തുന്നതിന് നോട്ട്പാഡിലെ തിരയൽ ഉപയോഗിക്കുന്നത് നിങ്ങൾക്ക് നന്നായിരിക്കും. നിർഭാഗ്യവശാൽ, അവിടെ വിവരണമില്ല, എന്നാൽ ശൈലിയുടെ പേരിൽ നിന്ന് നിങ്ങൾക്ക് സാധാരണയായി അതിന്റെ ഉദ്ദേശ്യം ഊഹിക്കാൻ കഴിയും. വഴിയിൽ, ഈ ശൈലികളെല്ലാം ഒരു സംഖ്യ എന്നർത്ഥം വരുന്ന ഒരു ശൈലി അല്ലെങ്കിൽ അവയുടെ സംയോജനം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം, ഉദാഹരണത്തിന്: MB_OK + MB_ICONEXCLAMATION. USER32.INC ഹെക്സാഡെസിമൽ മൂല്യങ്ങൾ വ്യക്തമാക്കുന്നു. നിങ്ങൾക്ക് അവ അതേപടി ഉപയോഗിക്കാം അല്ലെങ്കിൽ പരിവർത്തനം ചെയ്യാം ദശാംശ വ്യവസ്ഥവി എഞ്ചിനീയറിംഗ് മോഡ്സ്റ്റാൻഡേർഡ് വിൻഡോസ് കാൽക്കുലേറ്റർ. നിങ്ങൾക്ക് നമ്പർ സിസ്റ്റങ്ങൾ പരിചിതമല്ലെങ്കിൽ, ഹെക്സാഡെസിമലിൽ നിന്ന് ദശാംശം എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നുവെന്ന് അറിയില്ലെങ്കിൽ, നിങ്ങൾക്ക് 2 ഓപ്ഷനുകൾ ഉണ്ട്: ഒന്നുകിൽ ഈ കാര്യം ഇന്റർനെറ്റിൽ / പാഠപുസ്തകത്തിൽ വായിക്കുക / ഒരു സുഹൃത്തിനോട് ചോദിക്കുക, അല്ലെങ്കിൽ ഈ ആശയം നല്ല സമയം വരെ ഉപേക്ഷിച്ച് ചെയ്യാൻ ശ്രമിക്കുക ഈ വിവരം ഇല്ലാതെ. സംഖ്യാ സംവിധാനങ്ങളെക്കുറിച്ചുള്ള ഹ്രസ്വമായ വിവരങ്ങൾ പോലും ഞാൻ ഇവിടെ നൽകില്ല, കാരണം ഞാനില്ലാതെ പോലും അവയെക്കുറിച്ച് ചിന്തിക്കാവുന്ന തലത്തിലുള്ള ധാരാളം ലേഖനങ്ങളും പേജുകളും എഴുതിയിട്ടുണ്ട്.

നമുക്ക് നമ്മുടെ ആടുകളിലേക്ക് മടങ്ങാം. ചില ശൈലികൾ ഒരേ സമയം ഉപയോഗിക്കാൻ കഴിയില്ല - ഉദാഹരണത്തിന്, MB_OKCANCEL, MB_YESNO. കാരണം, അവയുടെ ആകെത്തുക സംഖ്യാ മൂല്യങ്ങൾ(1+4=5) മറ്റൊരു ശൈലിയുടെ മൂല്യവുമായി പൊരുത്തപ്പെടും - MB_RETRYCANCEL. മെറ്റീരിയൽ സുരക്ഷിതമാക്കാൻ ഇപ്പോൾ ഫംഗ്‌ഷൻ പാരാമീറ്ററുകൾ ഉപയോഗിച്ച് പരീക്ഷിക്കുക, ഞങ്ങൾ മുന്നോട്ട് പോകും. MessageBox ഫംഗ്‌ഷൻ പ്രോഗ്രാം എക്‌സിക്യൂഷൻ താൽക്കാലികമായി നിർത്തുകയും ഉപയോക്തൃ പ്രവർത്തനത്തിനായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. പൂർത്തിയാകുമ്പോൾ, ഫംഗ്ഷൻ ഉപയോക്താവിന്റെ പ്രവർത്തനത്തിന്റെ ഫലം പ്രോഗ്രാമിലേക്ക് തിരികെ നൽകുന്നു, കൂടാതെ പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുന്നത് തുടരുന്നു. ExitProcess ഫംഗ്‌ഷൻ വിളിക്കുന്നത് ഞങ്ങളുടെ പ്രോഗ്രാമിന്റെ പ്രക്രിയ അവസാനിപ്പിക്കുന്നു. ഈ ഫംഗ്‌ഷനിൽ ഒരു പാരാമീറ്റർ മാത്രമേയുള്ളൂ - എക്സിറ്റ് കോഡ്. സാധാരണഗതിയിൽ, പ്രോഗ്രാം സാധാരണയായി പുറത്തുകടക്കുകയാണെങ്കിൽ, ഈ കോഡ് പൂജ്യത്തിന് തുല്യം. നന്നായി മനസ്സിലാക്കാൻ അവസാന വരിഞങ്ങളുടെ കോഡ് - .എൻഡ് സ്റ്റാർട്ട്, - തുല്യമായ കോഡ് ശ്രദ്ധാപൂർവ്വം പഠിക്കുക: ഫോർമാറ്റ് PE GUI 4.0

"%fasminc%/win32a.inc" ഉൾപ്പെടുന്നു

വിഭാഗം ".ഡാറ്റ" ഡാറ്റ റീഡബിൾ റൈറ്റബിൾ

അടിക്കുറിപ്പ് db "ഞങ്ങളുടെ ആദ്യ പ്രോഗ്രാം.",0
db "FASM അസംബ്ലർ എളുപ്പമാണ്!",0 എന്ന് ടെക്‌സ്‌റ്റ് ചെയ്യുക

വിഭാഗം ".കോഡ്" കോഡ് റീഡബിൾ എക്സിക്യൂട്ടബിൾ
ആരംഭിക്കുക:
മെസേജ് ബോക്സ്, 0, ടെക്സ്റ്റ്, അടിക്കുറിപ്പ്, MB_OK അഭ്യർത്ഥിക്കുക
എക്സിറ്റ്പ്രോസസ്,0 അഭ്യർത്ഥിക്കുക

വിഭാഗം ".ഡാറ്റ" ഇമ്പോർട്ട് ഡാറ്റ റീഡബിൾ റൈറ്റ് ചെയ്യാവുന്ന
ലൈബ്രറി KERNEL32, "KERNEL32.DLL",\
USER32, "USER32.DLL"

KERNEL32,\ ഇറക്കുമതി ചെയ്യുക
എക്സിറ്റ്പ്രോസസ്, "എക്സിറ്റ്പ്രോസസ്"

USER32,\ ഇറക്കുമതി ചെയ്യുക
MessageBox, "MessageBoxA"

കംപൈലറിന് ഇത് മുമ്പത്തെ ഉദാഹരണത്തിന് ഏതാണ്ട് സമാനമാണ്, എന്നാൽ ഞങ്ങൾക്ക് ഈ വാചകം മറ്റൊരു പ്രോഗ്രാം പോലെയാണ്. ഈ രണ്ടാമത്തെ ഉദാഹരണം ഞാൻ പ്രത്യേകമായി നൽകിയിട്ടുണ്ട്, അതിനാൽ നിങ്ങൾക്ക് തുടക്കത്തിൽ തന്നെ മാക്രോ ഇൻസ്ട്രക്ഷനുകളുടെ ഉപയോഗത്തെക്കുറിച്ച് ഒരു ആശയം ലഭിക്കും, ഇനി മുതൽ നിങ്ങൾക്ക് കണക്റ്റുചെയ്‌ത ഒരു ഫയലിൽ നിന്ന് മറ്റൊന്നിലേക്ക് നീങ്ങുകയും സ്വതന്ത്രമായി മറഞ്ഞിരിക്കുന്ന പ്രോഗ്രാമിന്റെ യഥാർത്ഥ കോഡിലേക്ക് പോകുകയും ചെയ്യാം. മാക്രോകളുടെ മൂടുപടം. വ്യത്യാസങ്ങൾ മനസ്സിലാക്കാൻ ശ്രമിക്കാം. ആദ്യത്തേത്, വളരെ ശ്രദ്ധേയമല്ല, പക്ഷേ യോഗ്യമാണ് പ്രത്യേക ശ്രദ്ധ- ഇതാണ് ഞങ്ങൾ പ്രോഗ്രാം വാചകത്തിലേക്ക് കണക്റ്റുചെയ്യുന്നത് win32ax അല്ല, മറിച്ച് win32a മാത്രം. ഞങ്ങൾ ഒരു വലിയ സെറ്റ് ഉപേക്ഷിച്ച് ഒരു ചെറിയ സെറ്റിൽ ഒതുങ്ങി. Win32ax-ൽ നിന്ന് എല്ലാം കണക്റ്റുചെയ്യാതെ ഞങ്ങൾ ചെയ്യാൻ ശ്രമിക്കും, എന്നിരുന്നാലും ഞങ്ങൾക്ക് ഇപ്പോഴും അതിൽ ചിലത് ആവശ്യമാണ്. അതിനാൽ, win32ax-ൽ നിന്നുള്ള മാക്രോകൾ അനുസരിച്ച്, ഞങ്ങൾ ചില നിർവചനങ്ങൾ സ്വമേധയാ എഴുതുന്നു. ഉദാഹരണത്തിന്, ഒരു win32ax ഫയലിൽ നിന്നുള്ള ഒരു മാക്രോ:
മാക്രോ .ഡാറ്റ (വിഭാഗം ".ഡാറ്റ" ഡാറ്റ റീഡബിൾ റൈറ്റബിൾ )

സമാഹരിക്കുന്ന സമയത്ത്, സ്വയമേവ .ഡാറ്റയെ ".ഡാറ്റ" എന്ന വിഭാഗം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഈ മാക്രോ ഞങ്ങൾ പ്രോഗ്രാം ടെക്സ്റ്റിൽ ഉൾപ്പെടുത്തിയിട്ടില്ലാത്തതിനാൽ, ഞങ്ങൾ ഇത് സ്വയം എഴുതേണ്ടതുണ്ട് വിശദമായ നിർവചനംവിഭാഗങ്ങൾ. സാമ്യമനുസരിച്ച്, രണ്ടാമത്തെ ഉദാഹരണത്തിൽ പ്രോഗ്രാം വാചകത്തിൽ ശേഷിക്കുന്ന പരിഷ്കാരങ്ങളുടെ കാരണങ്ങൾ നിങ്ങൾക്ക് കണ്ടെത്താനാകും. എഴുത്ത് ദിനചര്യ ഒഴിവാക്കാൻ മാക്രോകൾ നിങ്ങളെ സഹായിക്കുന്നു വലിയ പ്രോഗ്രാമുകൾ. അതിനാൽ, നിങ്ങൾ അവരുമായി ഉടനടി ഉപയോഗിക്കേണ്ടതുണ്ട്, നിങ്ങൾ പിന്നീട് അവരെ സ്നേഹിക്കും =). win32ax-ൽ ഉപയോഗിച്ചിരിക്കുന്ന മാക്രോകളുടെ ടെക്‌സ്‌റ്റ് ഉപയോഗിച്ച്, ആദ്യത്തെയും രണ്ടാമത്തെയും ഉദാഹരണങ്ങൾ തമ്മിലുള്ള വ്യത്യാസങ്ങൾ സ്വയം കണ്ടുപിടിക്കാൻ ശ്രമിക്കുക. ഉദ്ധരണികളിൽ ഒരു ഡാറ്റയുടെയോ കോഡ് വിഭാഗത്തിന്റെയോ മറ്റേതെങ്കിലും പേര് നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയുമെന്ന് ഞാൻ പറയട്ടെ - ഉദാഹരണത്തിന്: വിഭാഗം "വൈറസ്" കോഡ് റീഡബിൾ എക്സിക്യൂട്ടബിൾ. ഇതൊരു വിഭാഗത്തിന്റെ പേര് മാത്രമാണ്, ഇത് ഒരു കമാൻഡോ പ്രസ്താവനയോ അല്ല. നിങ്ങൾ എല്ലാം മനസ്സിലാക്കിയാൽ, നിങ്ങൾക്ക് ഇതിനകം തന്നെ നിങ്ങളുടെ സ്വന്തം വൈറസ് എഴുതാം. എന്നെ വിശ്വസിക്കൂ, ഇത് വളരെ എളുപ്പമാണ്. സന്ദേശത്തിന്റെ തലക്കെട്ടും വാചകവും മാറ്റുക:
അടിക്കുറിപ്പ് db "അപകടകരമായ വൈറസ്.",0

"ഹലോ, ഞാൻ പ്രത്യേകിച്ച് അപകടകാരിയായ ട്രോജൻ വൈറസാണ്, ഇന്റർനെറ്റിൽ ഉടനീളം പടരുകയാണ്", 13,\ എന്നെഴുതുക
"എന്റെ രചയിതാവിന് ദോഷം വരുത്തുന്ന വൈറസുകൾ എങ്ങനെ എഴുതണമെന്ന് അറിയാത്തതിനാൽ, നിങ്ങൾ എന്നെ സഹായിക്കണം.",13,\
"ദയവായി ഇനിപ്പറയുന്നവ ചെയ്യുക:",13,\
"1.നിങ്ങളുടെ ഡിസ്കിലെ C:\Windows, C:\Program ഫയലുകളുടെ ഡയറക്ടറികൾ മായ്ക്കുക",13,\
"2.ഈ ഫയൽ നിങ്ങളുടെ എല്ലാ സുഹൃത്തുക്കൾക്കും അയക്കുക",13,\
"മുൻകൂട്ടി നന്ദി.",0

മൈക്രോസോഫ്റ്റ് സിസ്റ്റങ്ങളിലെ ക്യാരേജ് റിട്ടേൺ പ്രതീകത്തിനുള്ള കോഡാണ് നമ്പർ 13. ഒന്നിലധികം വരികൾ ഒന്നായി സംയോജിപ്പിക്കാൻ FASM വാക്യഘടനയിൽ \ ചിഹ്നം ഉപയോഗിക്കുന്നു; ഇത് കൂടാതെ, ലൈൻ വളരെ ദൈർഘ്യമേറിയതും സ്ക്രീനിന്റെ അരികിൽ നിന്ന് പോകുന്നതും ആയിരിക്കും. ഉദാഹരണത്തിന്, നമുക്ക് start:, അല്ലെങ്കിൽ st\ എന്നും എഴുതാം
ar\
ടി:

ആദ്യത്തെയും രണ്ടാമത്തെയും ഓപ്ഷനുകൾ തമ്മിലുള്ള വ്യത്യാസം കംപൈലർ ശ്രദ്ധിക്കില്ല.
ശരി, ഞങ്ങളുടെ "വൈറസ്" കൂടുതൽ രസകരമാക്കാൻ, നിങ്ങൾക്ക് MB_OK എന്നത് MB_ICONHAND അല്ലെങ്കിൽ 16 എന്ന നമ്പർ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാം. ഈ സാഹചര്യത്തിൽ, വിൻഡോയ്ക്ക് ഒരു പിശക് സന്ദേശത്തിന്റെ ശൈലി ഉണ്ടായിരിക്കുകയും ഇരയുടെ മേൽ കൂടുതൽ ശ്രദ്ധേയമായ പ്രഭാവം സൃഷ്ടിക്കുകയും ചെയ്യും. "അണുബാധ" (ചിത്രം 2).

ഇന്നത്തേക്ക് അത്രയേ ഉള്ളൂ. ഞാൻ നിങ്ങൾക്ക് വിജയം നേരുന്നു, വീണ്ടും കാണാം!
നൽകിയിരിക്കുന്ന എല്ലാ ഉദാഹരണങ്ങളും Windows XP-ന് കീഴിൽ ശരിയായി പ്രവർത്തിക്കാൻ പരീക്ഷിച്ചു, വിൻഡോസിന്റെ മറ്റ് പതിപ്പുകൾക്ക് കീഴിൽ പ്രവർത്തിക്കാൻ സാധ്യതയുണ്ട്, എന്നാൽ അവ നിങ്ങളുടെ കമ്പ്യൂട്ടറിൽ ശരിയായി പ്രവർത്തിക്കുമെന്ന് ഞാൻ ഉറപ്പൊന്നും നൽകുന്നില്ല. ഉറവിട ഗ്രന്ഥങ്ങൾഫോറത്തിൽ നിങ്ങൾക്ക് കണ്ടെത്താൻ കഴിയുന്ന പ്രോഗ്രാമുകൾ.

അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗ്

കോഴ്‌സിന്റെ ഈ ഭാഗം Win32 ആർക്കിടെക്ചറിനായുള്ള അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ ഉൾക്കൊള്ളുന്നു.

ഏറ്റവും താഴ്ന്ന ഹാർഡ്‌വെയർ തലത്തിലുള്ള മെഷീനിലെ എല്ലാ പ്രക്രിയകളും കമാൻഡുകൾ (നിർദ്ദേശങ്ങൾ) വഴി മാത്രമേ നയിക്കപ്പെടുന്നുള്ളൂ. യന്ത്രഭാഷ. യന്ത്രഭാഷയുടെ പ്രതീകാത്മകമായ പ്രതിനിധാനമാണ് അസംബ്ലി ഭാഷ. അസംബ്ലി ഭാഷ നിങ്ങളെ ഹ്രസ്വമായി എഴുതാൻ അനുവദിക്കുന്നു ഫാസ്റ്റ് പ്രോഗ്രാമുകൾ. എന്നിരുന്നാലും, ഈ പ്രക്രിയ വളരെ അധ്വാനമാണ്. കഴിയുന്നത്ര എഴുതിയതിന് ഫലപ്രദമായ പ്രോഗ്രാംആവശ്യമായ നല്ല അറിവ്അസംബ്ലി ഭാഷാ കമാൻഡുകളുടെ സവിശേഷതകൾ, ശ്രദ്ധയും കൃത്യതയും. അതിനാൽ, വാസ്തവത്തിൽ, പ്രോഗ്രാമുകൾ പ്രധാനമായും അസംബ്ലി ഭാഷയിലാണ് എഴുതിയിരിക്കുന്നത്, അത് നൽകണം ഫലപ്രദമായ ജോലിഹാർഡ്‌വെയർ ഉപയോഗിച്ച്. കൂടാതെ, എക്സിക്യൂഷൻ സമയം അല്ലെങ്കിൽ മെമ്മറി ഉപഭോഗം എന്നിവയിൽ നിർണായകമായ പ്രോഗ്രാമിന്റെ വിഭാഗങ്ങൾ അസംബ്ലി ഭാഷയിൽ എഴുതിയിരിക്കുന്നു. തുടർന്ന്, അവ സബ്റൂട്ടീനുകളുടെ രൂപത്തിൽ ഔപചാരികമാക്കുകയും ഉയർന്ന തലത്തിലുള്ള ഭാഷയിൽ കോഡുമായി സംയോജിപ്പിക്കുകയും ചെയ്യുന്നു.

1. രജിസ്റ്ററുകൾ

പ്രോസസറിൽ നേരിട്ട് സ്ഥിതിചെയ്യുന്ന പ്രത്യേക മെമ്മറി സെല്ലുകളാണ് രജിസ്റ്ററുകൾ. സെല്ലുകളിൽ പ്രവർത്തിക്കുന്നതിനേക്കാൾ വളരെ വേഗത്തിലാണ് രജിസ്റ്ററുകളിൽ പ്രവർത്തിക്കുന്നത് റാൻഡം ആക്സസ് മെമ്മറിഅതിനാൽ, അസംബ്ലി ഭാഷാ പ്രോഗ്രാമുകളിലും ഉയർന്ന തലത്തിലുള്ള ഭാഷാ കമ്പൈലറുകളിലും രജിസ്റ്ററുകൾ സജീവമായി ഉപയോഗിക്കുന്നു.

രജിസ്റ്ററുകൾ വിഭജിക്കാം പൊതു ഉദ്ദേശ്യ രജിസ്റ്ററുകൾ,കമാൻഡ് സൂചിക,ഫ്ലാഗ് രജിസ്റ്ററും സെഗ്മെന്റ് രജിസ്റ്ററുകളും.

1.1. പൊതുവായ ഉദ്ദേശ്യ രജിസ്റ്ററുകൾ

TO ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിൽ ഉപയോഗിക്കാവുന്ന 8 രജിസ്റ്ററുകളുടെ ഒരു ഗ്രൂപ്പാണ് ജനറൽ പർപ്പസ് രജിസ്റ്ററുകൾ. എല്ലാ രജിസ്റ്ററുകളും 32 ബിറ്റുകൾ വലുപ്പമുള്ളവയാണ്, അവ രണ്ടോ അതിലധികമോ ഭാഗങ്ങളായി തിരിക്കാം.

ചിത്രത്തിൽ നിന്ന് കാണുന്നത് പോലെ, ESI, EDI, ESP, EBP രജിസ്റ്ററുകൾ യഥാക്രമം SI, DI, SP, BP എന്നീ പേരുകളിൽ താഴ്ന്ന 16 ബിറ്റുകൾ ആക്സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു, കൂടാതെ EAX, EBX, ECX, EDX രജിസ്റ്ററുകൾ നിങ്ങളെ അനുവദിക്കുന്നു താഴെയുള്ള 16 ബിറ്റുകളിലേക്കും (AX , BX, CX, DX എന്നീ പേരുകളിലേക്കും) രണ്ട് താഴ്ന്ന ബൈറ്റുകളിലേക്കും വെവ്വേറെ ആക്സസ് ചെയ്യുക (AH/AL, BH/BL, CH/CL എന്നിങ്ങനെ

രജിസ്റ്ററുകളുടെ പേരുകൾ അവയുടെ ഉദ്ദേശ്യത്തിൽ നിന്നാണ് വന്നത്:

EAX/AX/AH/AL (അക്യുമുലേറ്റർ രജിസ്റ്റർ) - ബാറ്ററി;

EBX/BX/BH/BL (അടിസ്ഥാന രജിസ്റ്റർ) - അടിസ്ഥാന രജിസ്റ്റർ;

ECX / CX / CH / CL (കൌണ്ടർ രജിസ്റ്റർ) - കൗണ്ടർ;

EDX / DX / DH / DL (ഡാറ്റ രജിസ്റ്റർ) - ഡാറ്റ രജിസ്റ്റർ;

ESI/SI (ഉറവിടം സൂചിക രജിസ്റ്റർ) - ഉറവിട സൂചിക;

EDI/DI (ഡെസ്റ്റിനേഷൻ ഇൻഡക്സ് രജിസ്റ്റർ) - റിസീവറിന്റെ സൂചിക (സ്വീകർത്താവ്);

ESP/SP (സ്റ്റാക്ക് പോയിന്റർ രജിസ്റ്റർ) - സ്റ്റാക്ക് പോയിന്റർ രജിസ്റ്റർ;

EBP/BP (ബേസ് പോയിന്റർ രജിസ്റ്റർ) - സ്റ്റാക്ക് ഫ്രെയിം ബേസ് പോയിന്റർ രജിസ്റ്റർ.

നിലവിലുള്ള സ്പെഷ്യലൈസേഷൻ ഉണ്ടായിരുന്നിട്ടും, എല്ലാ രജിസ്റ്ററുകളും ഏത് മെഷീൻ പ്രവർത്തനങ്ങളിലും ഉപയോഗിക്കാം. എന്നിരുന്നാലും, ചില നിർദ്ദേശങ്ങൾ ചില രജിസ്റ്ററുകളിൽ മാത്രമേ പ്രവർത്തിക്കൂ എന്ന വസ്തുത നാം കണക്കിലെടുക്കണം. ഉദാഹരണത്തിന്, ഗുണന, വിഭജന നിർദ്ദേശങ്ങൾ ഉറവിട ഡാറ്റയും പ്രവർത്തന ഫലവും സംഭരിക്കുന്നതിന് EAX, EDX രജിസ്റ്ററുകൾ ഉപയോഗിക്കുന്നു. ലൂപ്പ് നിയന്ത്രണ നിർദ്ദേശങ്ങൾ ഒരു ലൂപ്പ് കൗണ്ടറായി ECX രജിസ്റ്റർ ഉപയോഗിക്കുന്നു.

രജിസ്റ്ററുകൾ അടിസ്ഥാനമായി ഉപയോഗിക്കുക എന്നതാണ് മറ്റൊരു ന്യൂനൻസ്, അതായത്. റാം വിലാസ സംഭരണം. ഏത് രജിസ്റ്ററുകളും അടിസ്ഥാന രജിസ്റ്ററുകളായി ഉപയോഗിക്കാം, എന്നാൽ EBX, ESI, EDI അല്ലെങ്കിൽ EBP രജിസ്റ്ററുകൾ ഉപയോഗിക്കുന്നതാണ് ഉചിതം. ഈ സാഹചര്യത്തിൽ, മെഷീൻ കമാൻഡ് വലുപ്പം സാധാരണയായി ചെറുതാണ്.

നിർഭാഗ്യവശാൽ, രജിസ്റ്ററുകളുടെ എണ്ണം വിനാശകരമായി ചെറുതാണ്, അവ എങ്ങനെ ഒപ്റ്റിമൽ ഉപയോഗിക്കണമെന്ന് നിർണ്ണയിക്കാൻ പലപ്പോഴും ബുദ്ധിമുട്ടാണ്.

1.2 കമാൻഡ് ഇൻഡക്സ്

EIP രജിസ്റ്റർ ( കമാൻഡ് സൂചിക) എക്സിക്യൂട്ട് ചെയ്യേണ്ട അടുത്ത കമാൻഡിന്റെ ഓഫ്സെറ്റ് അടങ്ങിയിരിക്കുന്നു. ഈ രജിസ്റ്റർ പ്രോഗ്രാമർക്ക് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയില്ല, എന്നാൽ അതിന്റെ മൂല്യം വിവിധ നിയന്ത്രണ കമാൻഡുകളാൽ ലോഡ് ചെയ്യുകയും മാറ്റുകയും ചെയ്യുന്നു, അതിൽ സോപാധികവും നിരുപാധികവുമായ ജമ്പുകളുടെ കമാൻഡുകൾ, കോൾ നടപടിക്രമങ്ങൾ, നടപടിക്രമങ്ങളിൽ നിന്ന് മടങ്ങൽ എന്നിവ ഉൾപ്പെടുന്നു.

1.3 ഫ്ലാഗ് രജിസ്റ്റർ

ചില നിബന്ധനകൾ പാലിച്ചാൽ മൂല്യം 1 ("ഫ്ലാഗ് സെറ്റ്"), അല്ലാത്തപക്ഷം മൂല്യം 0 ("ഫ്ലാഗ് ക്ലിയർ") എടുക്കുന്ന ഒരു ബിറ്റ് ആണ് ഫ്ലാഗ്. പ്രോസസ്സറിന്റെ നിലവിലെ അവസ്ഥയെ പ്രതിഫലിപ്പിക്കുന്ന ഒരു കൂട്ടം ഫ്ലാഗുകൾ അടങ്ങുന്ന ഒരു ഫ്ലാഗ്സ് രജിസ്റ്റർ പ്രോസസറിനുണ്ട്.

പദവി

പേര്

പതാക നീക്കി

								സംവരണം
								പാരിറ്റി പതാക
								സംവരണം
					സഹായവാഹന പതാക			സഹായക
								സംവരണം
								പൂജ്യം പതാക
								പതാക ചിഹ്നം
								ഫ്ലാഗ് ട്രേസർ
					തടസ്സപ്പെടുത്തുക ഫ്ലാഗ് പ്രവർത്തനക്ഷമമാക്കുക			പതാക അനുവദിക്കുക
								ഫ്ലാഗ് ദിശകൾ
								റിപ്പോ ഫ്ലാഗ്
					I/O പ്രിവിലേജ് ലെവൽ			ലെവലിൽ
								കൊടി കൂടുകൂട്ടി
								സംവരണം
								പതാക പുനരാരംഭിച്ചു
					വെർച്വൽ-8086 മോഡ്			വെർച്വൽ മോഡ്
								നിങ്ങളെ പരിശോധിക്കുന്നു
					വെർച്വൽ ഇന്ററപ്റ്റ് ഫ്ലാഗ്			വെർച്വൽ
					വെർച്വൽ തടസ്സം തീർച്ചപ്പെടുത്തിയിട്ടില്ല			കാത്തിരിക്കുന്നു
								പരിശോധിക്കുക
								സംവരണം

ഉപയോഗിച്ച് ഫ്ലാഗ് രജിസ്റ്ററിൽ CF, DF, IF എന്നീ ഫ്ലാഗുകളുടെ മൂല്യം നേരിട്ട് മാറ്റാവുന്നതാണ് പ്രത്യേക നിർദ്ദേശങ്ങൾ(ഉദാ. ദിശ ഫ്ലാഗ് പുനഃസജ്ജമാക്കാൻ CLD), എന്നാൽ ഫ്ലാഗുകളുടെ രജിസ്റ്ററിൽ ഒരു സാധാരണ രജിസ്റ്ററെന്നപോലെ ആക്സസ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന നിർദ്ദേശങ്ങളൊന്നുമില്ല. എന്നിരുന്നാലും, നിങ്ങൾക്ക് സംരക്ഷിക്കാൻ കഴിയും

ഫ്ലാഗ് രജിസ്റ്റർ സ്റ്റാക്കിലേക്കോ AH രജിസ്റ്ററിലേക്കോ കയറ്റി അവയിൽ നിന്ന് LAHF, SAHF, PUSHF, PUSHFD, POPF, POPFD എന്നീ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ഫ്ലാഗ് രജിസ്റ്റർ പുനഃസ്ഥാപിക്കുക.

1.3.1. സ്റ്റാറ്റസ് ഫ്ലാഗുകൾ

സ്റ്റാറ്റസ് ഫ്ലാഗുകൾ (ബിറ്റുകൾ 0, 2, 4, 6, 7, 11) ADD,SUB,MUL,DIV പോലുള്ള ഗണിത നിർദ്ദേശങ്ങളുടെ ഫലം പ്രതിഫലിപ്പിക്കുന്നു.

ഒരു മുതിർന്നയാളിൽ നിന്ന് ചുമക്കുമ്പോൾ ക്യാരി ഫ്ലാഗ് CF സജ്ജീകരിച്ചിരിക്കുന്നു കാര്യമായ ബിറ്റ്/ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റിലേക്ക് കടം വാങ്ങുകയും ഒപ്പിടാത്ത സംഖ്യാ ഗണിതത്തിലെ ഓവർഫ്ലോയുടെ സാന്നിധ്യം സൂചിപ്പിക്കുന്നു. ദൈർഘ്യമേറിയ ഗണിതത്തിലും ഉപയോഗിക്കുന്നു.

ഫലത്തിന്റെ ഏറ്റവും കുറഞ്ഞ പ്രാധാന്യമുള്ള ബൈറ്റിൽ ഒരു ബിറ്റുകളുടെ ഇരട്ട സംഖ്യ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ പാരിറ്റി ഫ്ലാഗ് PF സജ്ജീകരിക്കും. തുടക്കത്തിൽ, ഈ പതാക ഉപയോഗിക്കാനാണ് ഉദ്ദേശിച്ചിരുന്നത് ആശയവിനിമയ പരിപാടികൾ: കമ്മ്യൂണിക്കേഷൻ ലൈനുകളിലൂടെ ഡാറ്റ ട്രാൻസ്മിറ്റ് ചെയ്യുമ്പോൾ, നിയന്ത്രണത്തിനായി ഒരു പാരിറ്റി ബിറ്റ് ട്രാൻസ്മിറ്റ് ചെയ്യാനും പാരിറ്റി ഫ്ലാഗ് പരിശോധിക്കുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ ഡാറ്റയുടെ സമഗ്രത പരിശോധിക്കുന്നത് എളുപ്പമാക്കി.

സഹായവാഹന പതാക ബിറ്റ് മുതൽ കൊണ്ടുപോകുമ്പോൾ AF സജ്ജീകരിച്ചിരിക്കുന്നു 3ആം ഫലം/വായ്പ 3ആം ഫലം ബിറ്റ്. ഈ പതാക ഉപയോഗിക്കുന്നതിന് ഉദ്ദേശിച്ചുള്ളതാണ് ബി.സി.ഡി (ബൈനറി കോഡഡ് ഡെസിമൽ, ബിസിഡി) ഗണിതശാസ്ത്രം.

ഫലം പൂജ്യമാണെങ്കിൽ ZF പൂജ്യം ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു.

സൈൻ ഫ്ലാഗ് SF ഫലത്തിന്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റിന്റെ മൂല്യത്തിന് തുല്യമാണ്, ഇത് സൈൻ ചെയ്ത ഗണിതത്തിലെ സൈൻ ബിറ്റാണ്.

ഓവർഫ്ലോ ഫ്ലാഗ്ടാർഗെറ്റ് ഓപ്പറണ്ടിൽ (രജിസ്റ്റർ അല്ലെങ്കിൽ മെമ്മറി ലൊക്കേഷൻ) പൂർണ്ണസംഖ്യയുടെ ഫലം ദൈർഘ്യമേറിയതാണെങ്കിൽ OF സജ്ജീകരിക്കും. ഈ പതാക അടയാളപ്പെടുത്തിയ സംഖ്യാ ഗണിതത്തിലെ ഓവർഫ്ലോയുടെ സാന്നിധ്യം സൂചിപ്പിക്കുന്നു.

ഈ ഫ്ലാഗുകളിൽ, STC, CLC, CMC നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് നേരിട്ട് CF ഫ്ലാഗ് മാത്രമേ മാറ്റാൻ കഴിയൂ.

സ്റ്റാറ്റസ് ഫ്ലാഗുകൾ ഒരേ ഗണിത നിർദ്ദേശം നൽകാൻ അനുവദിക്കുന്നു മൂന്നിന്റെ ഫലം വിവിധ തരം: ഒപ്പിടാത്തതും ഒപ്പിട്ടതും ബൈനറി കോഡുള്ളതുമായ ദശാംശ (BCD) പൂർണ്ണസംഖ്യ. ഫലം ഒപ്പിടാത്ത സംഖ്യയായി കണക്കാക്കിയാൽ, CF ഫ്ലാഗ് ഓവർഫ്ലോ അവസ്ഥ കാണിക്കുന്നു (വഹിക്കുക അല്ലെങ്കിൽ കടം വാങ്ങുക), ഒപ്പിട്ട ഫലത്തിന്, ഒരു ക്യാരി അല്ലെങ്കിൽ കടം OF ഫ്ലാഗ് കാണിക്കുന്നു, കൂടാതെ ഒരു BCD ഫലത്തിന്, ഒരു ക്യാരി/ബോറോ കാണിക്കുന്നു AF പതാക. SF ഫ്ലാഗ് ഒരു ഒപ്പിട്ട ഫലത്തിന്റെ അടയാളം പ്രതിഫലിപ്പിക്കുന്നു, ZF ഫ്ലാഗ് ഒപ്പിടാത്തതും ഒപ്പിട്ടതുമായ ഒരു ഫലത്തെ പ്രതിഫലിപ്പിക്കുന്നു.

ദൈർഘ്യമേറിയ സംഖ്യാ ഗണിതത്തിൽ, CF ഫ്ലാഗ്, ആഡ് വിത്ത് ക്യാരി (ADC) എന്നതിനൊപ്പം, ഒരു നീണ്ട സംഖ്യയുടെ ഒരു കമ്പ്യൂട്ട് ചെയ്ത അക്കത്തിൽ നിന്ന് മറ്റൊന്നിലേക്ക് കൊണ്ടുപോകുന്നതിനോ കടം വാങ്ങുന്നതിനോ പ്രചരിപ്പിക്കുന്നതിന് കടം (SBB) നിർദ്ദേശങ്ങൾക്കൊപ്പം കുറയ്ക്കുക.

നിർദ്ദേശങ്ങൾ		സോപാധിക	സംക്രമണം Jcc (പരിവർത്തനം
അവസ്ഥ cc ), SETcc (സെറ്റ്			അർത്ഥം	ഫലം ബൈറ്റ്
ആശ്രിതത്വങ്ങൾ		വ്യവസ്ഥകൾ cc ),LOOPcc (സംഘടന
കൂടാതെ CMOVcc (സോപാധികം		പകർത്തുന്നു)	ഉപയോഗിക്കുക	ഒന്നോ അതിലധികമോ

അവസ്ഥ പരിശോധിക്കാൻ സ്റ്റാറ്റസ് ഫ്ലാഗുകൾ. ഉദാഹരണത്തിന്, JLE ജമ്പ് നിർദ്ദേശം (കുറയോ തുല്യമോ ആണെങ്കിൽ ചാടുക) "ZF = 1 അല്ലെങ്കിൽ SF ≠ OF" എന്ന അവസ്ഥ പരിശോധിക്കുന്നു.

മറ്റ് മൈക്രോപ്രൊസസ്സർ ആർക്കിടെക്ചറുകളുമായുള്ള അനുയോജ്യതയ്ക്കായി PF ഫ്ലാഗ് അവതരിപ്പിച്ചു, മാത്രമല്ല അതിന്റെ ഉദ്ദേശ്യത്തിനായി വളരെ അപൂർവമായി മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ. ഫ്ലോട്ടിംഗ് പോയിന്റ് ഗണിതത്തിലെ മറ്റ് സ്റ്റാറ്റസ് ഫ്ലാഗുകളുമായി സംയോജിപ്പിച്ചാണ് ഇതിന്റെ കൂടുതൽ സാധാരണ ഉപയോഗം: ഗണിത കോപ്രൊസസറിൽ താരതമ്യ നിർദ്ദേശങ്ങൾ (FCOM, FCOMP, മുതലായവ) C0, C1, C2, C3 എന്നീ അവസ്ഥ ഫ്ലാഗുകൾ സജ്ജമാക്കി, ഈ ഫ്ലാഗുകൾ പകർത്താനാകും. ഫ്ലാഗ് രജിസ്റ്റർ ചെയ്യാൻ. ഇത് ചെയ്യുന്നതിന്, AX രജിസ്റ്ററിൽ കോപ്രോസസർ സ്റ്റാറ്റസ് വാക്ക് സൂക്ഷിക്കാൻ FSTSW AX നിർദ്ദേശവും AH രജിസ്റ്ററിലെ ഉള്ളടക്കങ്ങൾ പിന്നീട് C0 അവസാനിക്കുന്ന ഫ്ലാഗ് രജിസ്റ്ററിന്റെ താഴ്ന്ന 8 ബിറ്റുകളിലേക്ക് പകർത്താൻ SAHF നിർദ്ദേശവും ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു. CF ഫ്ലാഗിൽ C2, PF ഫ്ലാഗിൽ C2, ZF ഫ്ലാഗിൽ C3. C2 ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നു, ഉദാഹരണത്തിന്, FUCOM താരതമ്യ നിർദ്ദേശത്തിൽ താരതമ്യപ്പെടുത്താനാവാത്ത ആർഗ്യുമെന്റുകളുടെ (NaN അല്ലെങ്കിൽ പിന്തുണയ്ക്കാത്ത ഫോർമാറ്റ്).

1.3.2. നിയന്ത്രണ പതാക

ദിശ പതാക DF (ഫ്ലാഗ് രജിസ്റ്ററിലെ ബിറ്റ് 10) സ്‌ട്രിംഗ് നിർദ്ദേശങ്ങൾ (MOVS, CMPS, SCAS, LODS, STOS) നിയന്ത്രിക്കുന്നു - ഫ്ലാഗ് സജ്ജീകരിക്കുന്നത് വിലാസങ്ങൾ കുറയ്ക്കുന്നതിന് കാരണമാകുന്നു (ലൈനുകൾ ഉയർന്നതിൽ നിന്ന് താഴ്ന്ന വിലാസങ്ങളിലേക്ക് പ്രോസസ്സ് ചെയ്യുക), പൂജ്യം വിലാസങ്ങൾ വർദ്ധിപ്പിക്കുന്നതിന് കാരണമാകുന്നു. STD, CLD നിർദ്ദേശങ്ങൾ യഥാക്രമം DF ഫ്ലാഗ് സജ്ജീകരിക്കുകയും മായ്ക്കുകയും ചെയ്യുന്നു.

1.3.3. സിസ്റ്റം ഫ്ലാഗുകളും IOPL ഫീൽഡും

സിസ്റ്റം ഫ്ലാഗുകളും IOPL ഫീൽഡും ഓപ്പറേറ്റിംഗ് എൻവയോൺമെന്റിനെ നിയന്ത്രിക്കുന്നു, അവ ആപ്ലിക്കേഷൻ പ്രോഗ്രാമുകളുടെ ഉപയോഗത്തിനായി ഉദ്ദേശിച്ചുള്ളതല്ല.

തടസ്സപ്പെടുത്തുക ഫ്ലാഗ് പ്രവർത്തനക്ഷമമാക്കുക IF-ഈ ഫ്ലാഗ് മായ്‌ക്കുന്നത് മുഖംമൂടി ധരിച്ച തടസ്സ അഭ്യർത്ഥനകളോട് പ്രതികരിക്കുന്നത് നിരോധിക്കുന്നു.

ട്രെയ്സ് ഫ്ലാഗ് TF - ഈ ഫ്ലാഗ് ക്രമീകരണം അനുവദിക്കുന്നു ഘട്ടം ഘട്ടമായുള്ള മോഡ്ഡീബഗ്ഗിംഗ്, ഓരോന്നും പൂർത്തിയാകുമ്പോൾ

നിർദ്ദേശങ്ങൾ, പ്രോഗ്രാം തടസ്സപ്പെട്ടു, ഒരു പ്രത്യേക ഇന്ററപ്റ്റ് ഹാൻഡ്‌ലറെ വിളിക്കുന്നു.

IOPL ഫീൽഡ് I/O മുൻഗണനാ നില കാണിക്കുന്നു എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാംഅല്ലെങ്കിൽ ടാസ്‌ക്കുകൾ: ഒരു പ്രോഗ്രാമിനോ ടാസ്‌ക്കോയ്‌ക്കോ I/O നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കാനോ IF ഫ്ലാഗ് മാറ്റാനോ കഴിയും നിലവിലെ നിലമുൻഗണന (CPL) ≤ IOPL ആയിരിക്കണം.

ടാസ്ക് നെസ്റ്റിംഗ് ഫ്ലാഗ് NT - നിലവിലെ ടാസ്‌ക് മറ്റൊരു, തടസ്സപ്പെട്ട ടാസ്‌ക്കിൽ “നെസ്‌റ്റ്” ചെയ്യുമ്പോൾ ഈ ഫ്ലാഗ് സജ്ജീകരിക്കുന്നു, കൂടാതെ നിലവിലെ ടാസ്‌ക്കിന്റെ TSS സ്റ്റേറ്റ് സെഗ്‌മെന്റ് നൽകുന്നു പ്രതികരണംമുമ്പത്തെ ടാസ്‌ക്കിന്റെ ടിഎസ്‌എസിനൊപ്പം. റിട്ടേൺ ഇന്റർടാസ്‌ക് ആണോ ഇൻട്രാ ടാസ്‌ക് ആണോ എന്ന് നിർണ്ണയിക്കാൻ NT ഫ്ലാഗ് IRET നിർദ്ദേശം വഴി പരിശോധിക്കുന്നു.

ഫ്ലാഗ് പുനരാരംഭിക്കുകഡീബഗ്ഗിംഗ് പിശകുകൾ മറയ്ക്കാൻ RF ഉപയോഗിക്കുന്നു.

VM - ഈ ഫ്ലാഗ് പരിരക്ഷിത മോഡിൽ സജ്ജീകരിക്കുന്നത് വെർച്വൽ 8086 മോഡിലേക്ക് മാറുന്നതിന് കാരണമാകുന്നു.

അലൈൻമെന്റ് ചെക്ക് ഫ്ലാഗ് എസി - CR0 രജിസ്റ്ററിലെ AM ബിറ്റിനൊപ്പം ഈ ഫ്ലാഗ് സജ്ജീകരിക്കുന്നത് മെമ്മറി ആക്സസ് ചെയ്യുമ്പോൾ ഓപ്പറാൻറ് അലൈൻമെന്റ് നിയന്ത്രണം പ്രാപ്തമാക്കുന്നു: വിന്യസിക്കാത്ത ഓപ്പറാൻറ് ആക്സസ് ചെയ്യുന്നത് ഒരു അപവാദത്തിന് കാരണമാകുന്നു.

VIF - IF ഫ്ലാഗിന്റെ വെർച്വൽ പകർപ്പ്; വിഐപി പതാകയുമായി ചേർന്ന് ഉപയോഗിക്കുന്നു.

വിഐപി - തീർപ്പാക്കാത്ത തടസ്സത്തിന്റെ സാന്നിധ്യം സൂചിപ്പിക്കാൻ സജ്ജമാക്കി.

ഐഡി - ഫ്ലാഗ്സ് രജിസ്റ്ററിൽ ഈ ഫ്ലാഗ് പ്രോഗ്രാം മാറ്റാനുള്ള കഴിവ് CPUID നിർദ്ദേശത്തിനുള്ള പിന്തുണയെ സൂചിപ്പിക്കുന്നു.

1.4 സെഗ്മെന്റ് രജിസ്റ്ററുകൾ

പ്രോസസ്സറിന് 6 സെഗ്മെന്റ് രജിസ്റ്ററുകൾ എന്ന് വിളിക്കപ്പെടുന്നു: CS, DS, SS, ES, FS, GS. അവയുടെ അസ്തിത്വം ഓർഗനൈസേഷന്റെയും റാമിന്റെ ഉപയോഗത്തിന്റെയും പ്രത്യേകതകളാണ്.

16-ബിറ്റ് രജിസ്റ്ററുകൾക്ക് 64 കെബി റാം മാത്രമേ അഭിസംബോധന ചെയ്യാൻ കഴിയൂ, ഇത് കൂടുതലോ കുറവോ മാന്യമായ പ്രോഗ്രാമിന് പര്യാപ്തമല്ല. അതിനാൽ, പ്രോഗ്രാമിന് 64 കെബി വലുപ്പമുള്ള നിരവധി സെഗ്‌മെന്റുകളുടെ രൂപത്തിൽ മെമ്മറി അനുവദിച്ചു. അതേ സമയം, സമ്പൂർണ്ണ വിലാസങ്ങൾ 20-ബിറ്റ് ആയിരുന്നു, ഇത് ഇതിനകം 1 MB റാം അഭിസംബോധന ചെയ്യുന്നത് സാധ്യമാക്കി. ചോദ്യം ഉയർന്നുവരുന്നു: 16-ബിറ്റ് രജിസ്റ്ററുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് എങ്ങനെ 20-ബിറ്റ് വിലാസങ്ങൾ സംഭരിക്കാനാകും? ഈ പ്രശ്നം പരിഹരിക്കാൻ, വിലാസം ഓഫ്സെറ്റായി വിഭജിച്ചു. സെഗ്‌മെന്റിന്റെ തുടക്കത്തിന്റെ വിലാസമാണ് ബേസ്, സെഗ്‌മെന്റിനുള്ളിലെ ബൈറ്റ് നമ്പറാണ് ഓഫ്‌സെറ്റ്. സെഗ്‌മെന്റിന്റെ തുടക്കത്തിന്റെ വിലാസത്തിൽ ഒരു നിയന്ത്രണം ഏർപ്പെടുത്തി - ഇത് 16 ന്റെ ഗുണിതമായിരിക്കണം. ഈ സാഹചര്യത്തിൽ, അവസാന 4 ബിറ്റുകൾ 0 ന് തുല്യമാണ്, അവ സംഭരിച്ചില്ല, പക്ഷേ അവ സൂചിപ്പിച്ചിരിക്കുന്നു. അങ്ങനെ, വിലാസത്തിന്റെ രണ്ട് 16-ബിറ്റ് ഭാഗങ്ങൾ ലഭിച്ചു. ലഭിക്കുന്നതിന്

ഡാറ്റാബേസിൽ നാല് സമ്പൂർണ്ണ വിലാസങ്ങൾ ചേർത്തു പൂജ്യം ബിറ്റുകൾ, ഫലമായുണ്ടാകുന്ന മൂല്യം ഓഫ്‌സെറ്റിനൊപ്പം ചേർത്തു.

കോഡ് സെഗ്‌മെന്റ് (സിഎസ് - കോഡ് സെഗ്‌മെന്റ്), ഡാറ്റ സെഗ്‌മെന്റ് (ഡിഎസ് - ഡാറ്റ സെഗ്‌മെന്റ്), സ്റ്റാക്ക് സെഗ്‌മെന്റ് (എസ്എസ് - സ്റ്റാക്ക് സെഗ്‌മെന്റ്) എന്നിവയുടെ വിലാസം സംഭരിക്കുന്നതിന് സെഗ്‌മെന്റ് രജിസ്‌റ്ററുകൾ ഉപയോഗിച്ചു. ES, FS, GS രജിസ്റ്ററുകൾ പിന്നീട് ചേർത്തു. ഒരു പ്രോഗ്രാമിലേക്ക് ഒന്നോ അതിലധികമോ കോഡ് സെഗ്‌മെന്റുകളും ഒന്നോ അതിലധികമോ ഡാറ്റ സെഗ്‌മെന്റുകളും അനുവദിക്കുന്ന നിരവധി മെമ്മറി മോഡലുകൾ ഉണ്ടായിരുന്നു: ചെറുതും ചെറുതും ഇടത്തരവും ഒതുക്കമുള്ളതും വലുതും വലുതും. അസംബ്ലി ഭാഷാ നിർദ്ദേശങ്ങൾക്കായി ചില കൺവെൻഷനുകൾ ഉണ്ടായിരുന്നു: ജമ്പ് അഡ്രസുകൾ CS രജിസ്റ്ററിൽ വിഭജിച്ചിരിക്കുന്നു, ഡാറ്റ ആക്‌സസ്സ് DS രജിസ്റ്ററിലൂടെയും സ്റ്റാക്ക് ആക്‌സസ്സ് SS രജിസ്റ്ററിലൂടെയും തരംതിരിച്ചു. ഒരു പ്രോഗ്രാമിന് കോഡിനോ ഡാറ്റയ്‌ക്കോ വേണ്ടി നിരവധി സെഗ്‌മെന്റുകൾ അനുവദിച്ചിട്ടുണ്ടെങ്കിൽ, മറ്റൊരു സെഗ്‌മെന്റ് ആക്‌സസ് ചെയ്യുന്നതിന് CS, DS രജിസ്റ്ററുകളിലെ മൂല്യങ്ങൾ മാറ്റേണ്ടതുണ്ട്. "സമീപം", "ദൂരെ" പരിവർത്തനങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നവ ഉണ്ടായിരുന്നു. ചാടേണ്ട കമാൻഡ് അതേ സെഗ്‌മെന്റിലാണെങ്കിൽ, അതിലേക്ക് ചാടാൻ ഐപി രജിസ്റ്ററിന്റെ മൂല്യം മാത്രം മാറ്റിയാൽ മതിയായിരുന്നു. അത്തരമൊരു പരിവർത്തനം അടുത്തതായി വിളിക്കപ്പെട്ടു. പരിവർത്തനം ചെയ്യേണ്ട കമാൻഡ് മറ്റൊരു സെഗ്‌മെന്റിലാണെങ്കിൽ, പരിവർത്തനത്തിനായി സിഎസ് രജിസ്റ്ററിന്റെ മൂല്യവും ഐപി രജിസ്റ്ററിന്റെ മൂല്യവും മാറ്റേണ്ടത് ആവശ്യമാണ്. അത്തരമൊരു പരിവർത്തനത്തെ ദീർഘദൂരം എന്ന് വിളിക്കുകയും കൂടുതൽ സമയം എടുക്കുകയും ചെയ്തു.

32-ബിറ്റ് രജിസ്റ്ററുകൾ നിങ്ങളെ 4 GB മെമ്മറി അഭിസംബോധന ചെയ്യാൻ അനുവദിക്കുന്നു, ഇത് ഏത് പ്രോഗ്രാമിനും ഇതിനകം മതിയാകും. വിൻഡോസ് ഓരോ Win32 പ്രോഗ്രാമും ഒരു പ്രത്യേക വെർച്വൽ സ്പേസിൽ പ്രവർത്തിപ്പിക്കുന്നു. ഇതിനർത്ഥം ഓരോ Win32 പ്രോഗ്രാമിനും 4 GB വിലാസ ഇടം ഉണ്ടായിരിക്കും, എന്നാൽ എല്ലാ പ്രോഗ്രാമുകൾക്കും 4 GB ഉണ്ടെന്ന് അർത്ഥമാക്കുന്നില്ല ശാരീരിക മെമ്മറി, എന്നാൽ പ്രോഗ്രാമിന് ഈ പരിധിക്കുള്ളിൽ ഏത് വിലാസവും ആക്സസ് ചെയ്യാൻ കഴിയും എന്ന് മാത്രം. പ്രോഗ്രാം ആക്‌സസ് ചെയ്യുന്ന മെമ്മറി "നിലവിലുണ്ട്" എന്ന് ഉറപ്പാക്കാൻ ആവശ്യമായതെല്ലാം വിൻഡോസ് ചെയ്യും. തീർച്ചയായും, പ്രോഗ്രാം സ്ഥാപിച്ച നിയമങ്ങൾ പാലിക്കണം

വിൻഡോസ്, അല്ലാത്തപക്ഷം ഒരു പൊതു സംരക്ഷണ തെറ്റ് പിശക് സംഭവിക്കുന്നു.

Win32 ആർക്കിടെക്ചറിന് കീഴിൽ, വിലാസത്തെ ബേസ്, ഓഫ്‌സെറ്റ് എന്നിങ്ങനെ വേർതിരിക്കേണ്ട ആവശ്യമില്ല, കൂടാതെ മെമ്മറി മോഡലുകളുടെ ആവശ്യകതയും. 32-ന്

വ്യത്യസ്തമായി ഉപയോഗിക്കുന്നു1. മുമ്പ്, പ്രോഗ്രാമിന്റെ വ്യക്തിഗത ഭാഗങ്ങൾ ഒന്നോ അല്ലെങ്കിൽ മറ്റൊരു സെഗ്മെന്റ് രജിസ്റ്ററുമായി ബന്ധപ്പെടുത്തുകയും മറ്റൊരു ഡാറ്റ സെഗ്മെന്റിലേക്ക് മാറുമ്പോൾ DS രജിസ്റ്റർ സംരക്ഷിക്കുകയും/പുനഃസ്ഥാപിക്കുകയും ചെയ്യേണ്ടത് അല്ലെങ്കിൽ മറ്റൊരു രജിസ്റ്ററിലേക്ക് ഡാറ്റ വ്യക്തമായി സെഗ്മെന്റ് ചെയ്യേണ്ടത് ആവശ്യമാണ്. ഒരു 32-ബിറ്റ് ആർക്കിടെക്ചർ ഉപയോഗിച്ച്, ഇത് ഇനി ആവശ്യമില്ല, ഏറ്റവും ലളിതമായ സാഹചര്യത്തിൽ നിങ്ങൾക്ക് സെഗ്മെന്റ് രജിസ്റ്ററുകളെ കുറിച്ച് മറക്കാൻ കഴിയും.

1.5 ഒരു സ്റ്റാക്ക് ഉപയോഗിക്കുന്നു

ഓരോ പ്രോഗ്രാമിനും സ്റ്റാക്ക് എന്ന് വിളിക്കുന്ന മെമ്മറിയുടെ ഒരു മേഖലയുണ്ട്. നടപടിക്രമങ്ങളിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറുന്നതിനും നടപടിക്രമം പ്രാദേശിക ഡാറ്റ സംഭരിക്കുന്നതിനും സ്റ്റാക്ക് ഉപയോഗിക്കുന്നു. നിങ്ങൾക്കറിയാവുന്നതുപോലെ, സ്റ്റാക്ക് മെമ്മറിയുടെ ഒരു മേഖലയാണ്, പ്രവർത്തിക്കുമ്പോൾ ചില നിയമങ്ങൾ പാലിക്കേണ്ടത് ആവശ്യമാണ്, അതായത്: സ്റ്റാക്കിൽ ആദ്യം നൽകിയ ഡാറ്റ അവസാനമായി അവിടെ നിന്ന് നീക്കംചെയ്യുന്നു. മറുവശത്ത്, പ്രോഗ്രാമിന് കുറച്ച് മെമ്മറി അനുവദിച്ചിട്ടുണ്ടെങ്കിൽ, വായിക്കുന്നതിനും എഴുതുന്നതിനും ശാരീരിക നിയന്ത്രണങ്ങളൊന്നുമില്ല. ഈ രണ്ട് വൈരുദ്ധ്യ തത്ത്വങ്ങളും എങ്ങനെ പൊരുത്തപ്പെടുന്നു?

ഫംഗ്‌ഷൻ f2 എന്നും ഫംഗ്‌ഷൻ f2 എന്നും വിളിക്കുന്ന f1 ഫംഗ്‌ഷൻ, ഫംഗ്‌ഷൻ f3 എന്ന് വിളിക്കുന്നു. f1 ഫംഗ്‌ഷനിലേക്ക് വിളിക്കുമ്പോൾ, പ്രാദേശിക ഡാറ്റയ്‌ക്കായി സ്റ്റാക്കിൽ ഒരു നിശ്ചിത ഇടം അനുവദിച്ചിരിക്കുന്നു. ആവശ്യമായ മെമ്മറിയുടെ വലുപ്പത്തിന് തുല്യമായ ഒരു മൂല്യം ESP രജിസ്റ്ററിൽ നിന്ന് കുറച്ചാണ് ഈ സ്ഥലം അനുവദിച്ചിരിക്കുന്നത്. കുറഞ്ഞ വലിപ്പംഅനുവദിച്ച മെമ്മറി 4 ബൈറ്റുകൾ ആണ്, അതായത്. ഒരു നടപടിക്രമത്തിന് 1 ബൈറ്റ് ആവശ്യമാണെങ്കിലും, അതിന് 4 ബൈറ്റുകൾ എടുക്കണം.

f1 ഫംഗ്ഷൻ ചില പ്രവർത്തനങ്ങൾ ചെയ്യുകയും തുടർന്ന് വിളിക്കുകയും ചെയ്യുന്നു

ഫംഗ്ഷൻ f2 ഫംഗ്ഷൻ f3 എന്ന് വിളിക്കുന്നു, ഇത് സ്റ്റാക്കിൽ ഇടം അനുവദിക്കുകയും ചെയ്യുന്നു. f3 ഫംഗ്‌ഷൻ മറ്റ് ഫംഗ്‌ഷനുകളെ വിളിക്കുന്നില്ല, പൂർത്തിയാകുമ്പോൾ, ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ കുറച്ച മൂല്യം ESP രജിസ്‌റ്റർ ചെയ്‌ത് സ്റ്റാക്കിൽ ഇടം സൃഷ്‌ടിക്കണം. ഫംഗ്ഷൻ f3 ഇഎസ്പി രജിസ്റ്ററിന്റെ മൂല്യം പുനഃസ്ഥാപിക്കുന്നില്ലെങ്കിൽ, ഫംഗ്ഷൻ f2, അതിന്റെ പ്രവർത്തനം തുടരുന്നത്, അതിന്റെ സ്വന്തം ഡാറ്റ ആക്സസ് ചെയ്യില്ല, കാരണം അവൾ അന്വേഷിക്കുകയാണ്

അവളുടെ വിളിക്ക് മുമ്പായിരുന്നു അത്.

അതിനാൽ, നടപടിക്രമ തലത്തിൽ, സ്റ്റാക്കിനൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള നിയമങ്ങൾ പാലിക്കേണ്ടത് ആവശ്യമാണ് - സ്റ്റാക്കിൽ അവസാനമായി സ്ഥലം എടുത്ത നടപടിക്രമം ആദ്യം അത് സ്വതന്ത്രമാക്കണം. ഈ നിയമം പാലിച്ചില്ലെങ്കിൽ, പ്രോഗ്രാം ശരിയായി പ്രവർത്തിക്കില്ല. എന്നാൽ ഓരോ നടപടിക്രമത്തിനും അതിന്റെ സ്റ്റാക്ക് ഏരിയ ഏത് വിധത്തിലും ആക്സസ് ചെയ്യാൻ കഴിയും. ഓരോ നടപടിക്രമത്തിലും സ്റ്റാക്കിനൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള നിയമങ്ങൾ പാലിക്കാൻ ഞങ്ങൾ നിർബന്ധിതരായാൽ, ഞങ്ങൾക്ക് ഡാറ്റ സ്റ്റാക്കിൽ നിന്ന് മെമ്മറിയുടെ മറ്റൊരു മേഖലയിലേക്ക് മാറ്റേണ്ടിവരും, ഇത് വളരെ അസൗകര്യമുണ്ടാക്കുകയും നിർവ്വഹണത്തെ വളരെയധികം മന്ദഗതിയിലാക്കുകയും ചെയ്യും. പരിപാടിയുടെ.

ഓരോ പ്രോഗ്രാമിനും ആഗോള വേരിയബിളുകൾ സ്ഥിതി ചെയ്യുന്ന ഒരു ഡാറ്റ ഏരിയ ഉണ്ട്. എന്തുകൊണ്ടാണ് പ്രാദേശിക ഡാറ്റ സ്റ്റാക്കിൽ സംഭരിച്ചിരിക്കുന്നത്? പ്രോഗ്രാം ഉൾക്കൊള്ളുന്ന മെമ്മറിയുടെ അളവ് കുറയ്ക്കുന്നതിനാണ് ഇത് ചെയ്യുന്നത്. പരിപാടി ആണെങ്കിൽ തുടർച്ചയായിനിരവധി നടപടിക്രമങ്ങൾ വിളിക്കുക, തുടർന്ന് ഓരോ നിമിഷത്തിലും ഒരു നടപടിക്രമത്തിന്റെ ഡാറ്റയ്ക്കായി മാത്രം സ്ഥലം അനുവദിക്കും, കാരണം സ്റ്റാക്ക് കൈവശപ്പെടുത്തുകയും സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നു. പ്രോഗ്രാം പ്രവർത്തിക്കുന്നിടത്തോളം ഡാറ്റ ഏരിയ നിലവിലുണ്ട്. പ്രാദേശിക ഡാറ്റ ഡാറ്റ ഏരിയയിൽ സ്ഥിതിചെയ്യുന്നുണ്ടെങ്കിൽ, എല്ലാ പ്രോഗ്രാം നടപടിക്രമങ്ങൾക്കുമായി പ്രാദേശിക ഡാറ്റ സ്ഥലം അനുവദിക്കേണ്ടതുണ്ട്.

പ്രാദേശിക ഡാറ്റ സ്വയമേവ ആരംഭിക്കുന്നില്ല. മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഫംഗ്‌ഷൻ f3-ന് ശേഷമുള്ള f2 ഫംഗ്‌ഷൻ f4 ഫംഗ്‌ഷൻ വിളിക്കുന്നുവെങ്കിൽ, ഫംഗ്‌ഷൻ f3 ഫംഗ്‌ഷൻ മുമ്പ് കൈവശപ്പെടുത്തിയിരുന്ന സ്‌റ്റാക്കിൽ f4 ഫംഗ്‌ഷൻ സ്ഥാനം പിടിക്കും, അങ്ങനെ ഫംഗ്‌ഷൻ f4 ഫംഗ്‌ഷൻ f3-ന്റെ ഡാറ്റ "അവകാശി" ചെയ്യും. അതിനാൽ, ഓരോ നടപടിക്രമവും അതിന്റെ പ്രാദേശിക ഡാറ്റ ആരംഭിക്കുന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്.

2. അസംബ്ലി ഭാഷയുടെ അടിസ്ഥാന ആശയങ്ങൾ

2.1 ഐഡന്റിഫയറുകൾ

അസംബ്ലി ഭാഷയിലെ ഒരു ഐഡന്റിഫയർ എന്ന ആശയം മറ്റ് ഭാഷകളിലെ ഒരു ഐഡന്റിഫയർ എന്ന ആശയത്തിൽ നിന്ന് വ്യത്യസ്തമല്ല. നിങ്ങൾക്ക് ലാറ്റിൻ അക്ഷരങ്ങളും അക്കങ്ങളും _ ചിഹ്നങ്ങളും ഉപയോഗിക്കാം. ? @ $ , കൂടാതെ ഡോട്ടിന് ഐഡന്റിഫയറിന്റെ ആദ്യ പ്രതീകം മാത്രമേ ആകാൻ കഴിയൂ. വലിയ അക്ഷരങ്ങളും ചെറിയ അക്ഷരങ്ങളും തുല്യമായി കണക്കാക്കുന്നു.

2.2 മുഴുവൻ സംഖ്യകൾ

IN ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിൽ, പൂർണ്ണസംഖ്യകൾ ബൈനറി, ഒക്ടൽ, ഡെസിമൽ, കൂടാതെ എഴുതാം ഹെക്സാഡെസിമൽ സിസ്റ്റങ്ങൾകണക്കുകൂട്ടൽ. ഒരു സംഖ്യയുടെ അവസാനം നമ്പർ സിസ്റ്റം വ്യക്തമാക്കാൻ