Cyber-Parallel-Dataset-Indic / ml /Assembly Language Step-by-Step Programming with DOS and Linux - Jeff Duntemann_indic_translation.jsonl
| {"en":"button is a handy way to do this if your calculator has one.","translation":"നിങ്ങളുടെ കാൽക്കുലേറ്ററിൽ ഒരു ബട്ടൺ ഉണ്ടെങ്കിൽ ഇത് ചെയ്യാൻ എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Remember what you're doing: evaluating each column in decimal and keeping a running total.","translation":"നിങ്ങൾ എന്താണ് ചെയ്യുന്നതെന്ന് ഓർമ്മിക്കുക: ഓരോ സ്തംഭവും ദശാംശത്തിൽ വിലയിരുത്തുകയും ഒരു റണ്ണിംഗ് ടോട്ടൽ സൂക്ഷിക്കുകയും ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Now, move to the third column from the right.","translation":"ഇനി, വലതുവശത്തുള്ള മൂന്നാമത്തെ സ്തംഭത്തിലേക്ക് നീങ്ങുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The value of the third column is 16 × 16, or 256.","translation":"മൂന്നാമത്തെ സ്തംഭത്തിന്റെ മൂല്യം 16 × 16 അല്ലെങ്കിൽ 256 ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Multiply 256 × 7 on your calculator, and add the product to your running total.","translation":"നിങ്ങളുടെ കാൽക്കുലേറ്ററിൽ 256 × 7 ഗുണിക്കുക, കൂടാതെ ഉൽപ്പന്നം നിങ്ങളുടെ റണ്ണിംഗ് ടോട്ടലിലേക്ക് ചേർക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Retrieve the running total from your calculator memory.","translation":"നിങ്ങളുടെ കാൽക്കുലേറ്റർ മെമ്മറിയിൽ നിന്ന് റണ്ണിംഗ് ടോട്ടൽ വീണ്ടെടുക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The total should be 1954, which is the decimal equivalent of 7A2H.","translation":"ആകെത്തുക 1954 ആയിരിക്കണം, ഇത് 7A2H ന്റെ ദശാംശത്തിന് തുല്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Okay—let's try it again, more quickly, with a little less natter and a much larger number: C6F0DBH.","translation":"ശരി - നമുക്ക് ഇത് വീണ്ടും വേഗത്തിൽ ശ്രമിക്കാം, അല്പം കുറഞ്ഞ സംസാരവും വളരെ വലിയ സംഖ്യയും: C6F0DBH.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"First, evaluate the units column.","translation":"ആദ്യം, യൂണിറ്റ് കോളം വിലയിരുത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 16s column.","translation":"16-ന്റെ കോളം വിലയിരുത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 256s column.","translation":"256-ന്റെ കോളം വിലയിരുത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 4,096s column.","translation":"4,096-ന്റെ കോളം വിലയിരുത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 65,536s column.","translation":"65,536-ന്റെ കോളം വിലയിരുത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Evaluate the 1,048,576s column.","translation":"1,048,576-ന്റെ കോളം വിലയിരുത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The running total should be 13,037,787.","translation":"റണ്ണിംഗ് ടോട്ടൽ 13,037,787 ആയിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Finally, do it yourself without any help for the following number: 1A55BEH.","translation":"അവസാനമായി, താഴെയുള്ള സംഖ്യയ്ക്കായി ആരുടെയും സഹായമില്ലാതെ ഇത് സ്വയം ചെയ്യുക: 1A55BEH.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"From Decimal to Hex The lights should be coming on about now.","translation":"ദശാംശത്തിൽ നിന്ന് Hex-ലേക്ക് ഇപ്പോൾ ലൈറ്റുകൾ തെളിയണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"What we have to do is find the hex column values within a decimal number—and that involves some considerable use of that fifth-grade bogeyman, long division.","translation":"നമ്മൾ ചെയ്യേണ്ടത് ഒരു ദശാംശ സംഖ്യയിലുള്ള ഹെക്സ് കോളം മൂല്യങ്ങൾ കണ്ടെത്തുക എന്നതാണ് - അതിൽ അഞ്ചാം ക്ലാസിലെ നീണ്ട ഡിവിഷൻ എന്ന ഭീകരജീവിയുടെ ഉപയോഗവും ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"But let's get to it, again, starting with a fairly easy number: 449.","translation":"എന്നാൽ നമുക്ക് വീണ്ടും തുടങ്ങാം, താരതമ്യേന എളുപ്പമുള്ള ഒരു സംഖ്യയിൽ നിന്ന്: 449.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The calculator will be handy with a vengeance.","translation":"കാൽക്കുലേറ്റർ പ്രതികാരത്തോടെ സഹായകമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Assembly Language Step-by-Step: Programming with DOS and Linux, Second Edition by Jeff Duntemann.","translation":"അസംബ്ലി ലാംഗ്വേജ് സ്റ്റെപ്പ്-ബൈ-സ്റ്റെപ്പ്: പ്രോഗ്രാമിംഗ് വിത്ത് ഡോസ് ആൻഡ് ലിനക്സ്, ജെഫ് ഡൺറ്റെമാൻ്റെ രണ്ടാം പതിപ്പ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This book is a guide to assembly language programming.","translation":"അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിനായുള്ള ഒരു വഴികാട്ടിയാണ് ഈ പുസ്തകം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The book covers both DOS and Linux operating systems.","translation":"പുസ്തകത്തിൽ DOS, Linux എന്നീ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളെക്കുറിച്ച് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"It explains the internal operations of Intel-based PCs.","translation":"ഇൻ്റൽ അടിസ്ഥാനമാക്കിയുള്ള കമ്പ്യൂട്ടറുകളുടെ ആന്തരിക പ്രവർത്തനങ്ങളെക്കുറിച്ച് ഇത് വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The author presents example programs for both DOS and Linux.","translation":"രചയിതാവ് DOS, Linux എന്നിവയ്ക്കായി ഉദാഹരണ പ്രോഗ്രാമുകൾ അവതരിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book also includes information on procedures and macros.","translation":"നടപടിക്രമങ്ങളെയും മാക്രോകളെയും കുറിച്ചുള്ള വിവരങ്ങളും പുസ്തകത്തിൽ ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembly language is a low-level programming language.","translation":"അസംബ്ലി ഭാഷ ഒരു താഴ്ന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"It provides a foundation for creating executable programs.","translation":"പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന പ്രോഗ്രാമുകൾ ഉണ്ടാക്കുന്നതിനുള്ള അടിസ്ഥാനം ഇത് നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book teaches how to use NASM-IDE.","translation":"NASM-IDE എങ്ങനെ ഉപയോഗിക്കാമെന്ന് പുസ്തകം പഠിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It details the elements of the 86-family instruction set.","translation":"86-കുടുംബത്തിലെ ഇൻസ്ട്രക്ഷൻ സെറ്റിൻ്റെ ഘടകങ്ങളെക്കുറിച്ച് ഇത് വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The book examines the operations that machine instructions force the CPU to perform.","translation":"മെഷീൻ നിർദ്ദേശങ്ങൾ CPU-വിനെക്കൊണ്ട് ചെയ്യിക്കുന്ന പ്രവർത്തനങ്ങൾ പുസ്തകം പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"It discusses the process of memory addressing.","translation":"മെമ്മറി വിലാസങ്ങളുടെ പ്രക്രിയയെക്കുറിച്ച് ഇത് ചർച്ച ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The author, Jeff Duntemann, is an editor and author.","translation":"എഴുത്തുകാരനായ ജെഫ് ഡൺറ്റെമാൻ ഒരു എഡിറ്ററും എഴുത്തുകാരനുമാണ്.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"The book is published by John Wiley & Sons.","translation":"ഈ പുസ്തകം പ്രസിദ്ധീകരിച്ചിരിക്കുന്നത് ജോൺ വൈലി & സൺസ് ആണ്.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"The book includes a CD-ROM with software.","translation":"പുസ്തകത്തിൽ സോഫ്റ്റ്വെയറുള്ള ഒരു CD-ROM ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The book is designed to provide accurate information.","translation":"കൃത്യമായ വിവരങ്ങൾ നൽകുന്ന രീതിയിലാണ് ഈ പുസ്തകം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"The book is not a substitute for professional advice.","translation":"ഈ പുസ്തകം ഒരു പ്രൊഫഷണൽ ഉപദേശത്തിന് പകരമാവില്ല.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"The book is dedicated to Kathleen M. Duntemann.","translation":"ഈ പുസ്തകം കാത്ലീൻ എം. ഡൺറ്റെമാൻ്റെ സ്മരണക്കായി സമർപ്പിക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"The author acknowledges the software authors.","translation":"എഴുത്തുകാരൻ സോഫ്റ്റ്വെയർ രചയിതാക്കളെ അംഗീകരിക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"Time passes, and so do the people who believe in us.","translation":"സമയം കടന്നുപോകുന്നു, നമ്മെ വിശ്വസിക്കുന്ന ആളുകളും കടന്നുപോകുന്നു.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"Computers work in base 2 and base 16.","translation":"കമ്പ്യൂട്ടറുകൾ ബേസ് 2-ലും ബേസ് 16-ലും പ്രവർത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Everything in assembly language depends on your understanding of these two number bases.","translation":"അസംബ്ലി ഭാഷയിലെ എല്ലാം തന്നെ ഈ രണ്ട് സംഖ്യാ അടിസ്ഥാനങ്ങളെക്കുറിച്ചുള്ള നിങ്ങളുടെ ധാരണയെ ആശ്രയിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Martians have three fingers on one hand, and only one finger on the other.","translation":"ചൊവ്വയിലെ ആളുകൾക്ക് ഒരു കയ്യിൽ മൂന്ന് വിരലുകളും, മറ്റേ കയ്യിൽ ഒരു വിരലും ഉണ്ട്.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"The Martians used their four fingers to set things off in groups and powers of four.","translation":"ചൊവ്വക്കാർ അവരുടെ നാല് വിരലുകൾ ഉപയോഗിച്ച് കാര്യങ്ങൾ ഗ്രൂപ്പുകളായും നാലിന്റെ കൃത്യങ്കങ്ങളായും തിരിച്ചു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The four digits follow, along with the names of the digits as the Martians pronounce them.","translation":"ചൊവ്വയിലെ ആളുകൾ ഉച്ചരിക്കുന്ന അക്കങ്ങളുടെ പേരുകൾക്കൊപ്പം നാല് അക്കങ്ങളും താഴെ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Like our zero, xip is a placeholder representing no items.","translation":"നമ്മുടെ പൂജ്യത്തെപ്പോലെ, xip ഒരു സ്ഥാന നിർണ്ണായകമാണ്, ഇത് ഒന്നിനെയും പ്രതിനിധീകരിക്കുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Fooby is the base of the Martian number system, and probably the most important number on Mars.","translation":"ചൊവ്വയിലെ സംഖ്യാ സമ്പ്രദായത്തിന്റെ അടിസ്ഥാനമാണ് Fooby, കൂടാതെ ചൊവ്വയിലെ ഏറ്റവും പ്രധാനപ്പെട്ട സംഖ്യയും ഇതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Each column has a value that is a power of fooby.","translation":"ഓരോ നിരയും fooby-യുടെ ശക്തിയെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The rightmost column represents units, in counts of foo.","translation":"വലതുവശത്തുള്ള കോളം, foo-യുടെ എണ്ണത്തിൽ, യൂണിറ്റുകളെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The next column over represents fooby times foo, or (given that arithmetic works the same way on Mars as here, New Math notwithstanding) simply fooby.","translation":"അടുത്ത കോളം fooby ഗുണം foo, അല്ലെങ്കിൽ (ചൊവ്വയിലെ ഗണിതവും ഇവിടുത്തെ ഗണിതവും തമ്മിൽ വ്യത്യാസമില്ലെങ്കിൽ) ലളിതമായി പറഞ്ഞാൽ fooby-യെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Dissecting a Martian Number","translation":"ചൊവ്വാ സംഖ്യയെ വിഭജിക്കുന്നു","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The digit there is bas, indicating that the number contains bas units.","translation":"അവിടെയുള്ള അക്കം bas ആണ്, അതായത് സംഖ്യയിൽ bas യൂണിറ്റുകൾ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In a columnar system of numeric notation like both ours and the Martians', the base of the number system is the magnitude by which each column of a number exceeds the magnitude of the column to its right.","translation":"നമ്മുടെയും ചൊവ്വയിലെയും സംഖ്യാ സമ്പ്രദായം പോലെ, ഓരോ സംഖ്യയുടെയും അടിസ്ഥാനം എന്നത്, ഒരു സംഖ്യയിലെ ഓരോ കോളവും അതിന്റെ വലതുവശത്തുള്ള കോളം എത്രത്തോളം വലുതാണോ അതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In our base 10 system, each column represents a value 10 times the column to its right.","translation":"നമ്മുടെ 10 അടിസ്ഥാന സമ്പ്രദായത്തിൽ, ഓരോ കോളവും അതിന്റെ വലതുവശത്തുള്ള കോളം 10 മടങ്ങ് മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Octal as a number base is very nearly extinct.","translation":"ഒരു സംഖ്യാ അടിസ്ഥാനമായി ഒക്ടൽ ഇപ്പോൾ ഏതാണ്ട് ഇല്ലാതായി.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Back in the sixties, DEC invented the minicomputer.","translation":"അറുപതുകളിൽ, DEC മിനി കമ്പ്യൂട്ടർ കണ്ടുപിടിച്ചു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In base 8, there must be eight digits.","translation":"ബേസ് 8-ൽ, എട്ട് അക്കങ്ങൾ ഉണ്ടായിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Counting in octal starts out in a very familiar fashion: one, two, three, four, five, six, seven...10.","translation":"ഒക്ടലിൽ എണ്ണുന്നത് വളരെ പരിചിതമായ രീതിയിലാണ്: ഒന്ന്, രണ്ട്, മൂന്ന്, നാല്, അഞ്ച്, ആറ്, ഏഴ്...10.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Each column in the hexadecimal system has a value 16 times that of the column to its right.","translation":"ഹെക്സാഡെസിമൽ സമ്പ്രദായത്തിലെ ഓരോ കോളം അതിന്റെ വലതുവശത്തുള്ള കോളം 16 മടങ്ങ് മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The easiest way to perform such conversions is by way of a hex calculator.","translation":"ഇത്തരം പരിവർത്തനങ്ങൾ നടത്താനുള്ള എളുപ്പവഴി ഒരു ഹെക്സ് കാൽക്കുലേറ്റർ ഉപയോഗിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"She takes a left down to the corner and fills the tank at Del's Shell.","translation":"അവൾ ഇടത്തോട്ട് തിരിഞ്ഞ് കോണിലേക്ക് പോയി ഡെൽ ഷെല്ലിൽ ടാങ്ക് നിറയ്ക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"Then, with a full tank, she continues the program by taking a U-turn and heading for Rand Park.","translation":"പിന്നെ, ടാങ്ക് നിറച്ച്, യു-ടേൺ എടുത്ത് റാന്റ് പാർക്കിലേക്ക് പോകുന്നതിലൂടെ അവൾ പ്രോഗ്രാം തുടരുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"In the abstract, a test consists of those two parts: First, you take a look at something that can go one of two ways.","translation":"അമൂർത്തമായി പറഞ്ഞാൽ, ഒരു പരീക്ഷണം രണ്ട് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു: ഒന്നാമതായി, രണ്ട് വഴികളിൽ ഒന്നിലേക്ക് പോകാൻ സാധ്യതയുള്ള ഒന്നിനെ നിങ്ങൾ നോക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Then you do one of two things, depending on what you saw when you took a look.","translation":"അതിനുശേഷം നിങ്ങൾ കണ്ടതിനെ ആശ്രയിച്ച് രണ്ട് കാര്യങ്ങളിൽ ഒന്ന് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Toward the end of the program, our homemaker got home, took the groceries out of the van, and took a look at the clock.","translation":"പ്രോഗ്രാമിന്റെ അവസാനം, വീട്ടമ്മ വീട്ടിലെത്തി, വാനിൽ നിന്ന് പലചരക്ക് സാധനങ്ങൾ എടുത്ത് ക്ലോക്കിലേക്ക് നോക്കി.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"If it isn't time to get Nicky back from Little League, she has a moment to collapse on the couch in a nearly empty house.","translation":"നിക്കിയെ ലിറ്റിൽ ലീഗിൽ നിന്ന് തിരികെ കൊണ്ടുവരാൻ സമയമായിട്ടില്ലെങ്കിൽ, ഏകദേശം ഒഴിഞ്ഞുകിടക്കുന്ന വീട്ടിലെ സോഫയിൽ വിശ്രമിക്കാൻ അവൾക്ക് അൽപസമയം കിട്ടും.","target_lang":"ml","domain":"general","complexity":"complex"} | |
| {"en":"If it is time to get Nicky, there's no rest for the ragged: She sprints for the van and heads back to Rand Park.","translation":"നിക്കിയെ കൂട്ടിക്കൊണ്ടുവരാൻ സമയമായെങ്കിൽ, വിശ്രമമില്ല: അവൾ വാനിലേക്ക് ഓടുകയും റാന്റ് പാർക്കിലേക്ക് തിരികെ പോവുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"Any guesses as to whether she really gets to collapse when the program is complete?","translation":"പ്രോഗ്രാം പൂർത്തിയാകുമ്പോൾ അവൾക്ക് ശരിക്കും വിശ്രമിക്കാൻ കഴിയുമോ എന്ന് ആരെങ്കിലും ഊഹിക്കാമോ?","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"You might object, saying that many or most tests involve more than two alternatives.","translation":"പല അല്ലെങ്കിൽ മിക്കവാറും ടെസ്റ്റുകളും രണ്ടിൽ കൂടുതൽ ബദലുകൾ ഉൾക്കൊള്ളുന്നു എന്ന് പറഞ്ഞ് നിങ്ങൾക്ക് എതിർക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Except for totally impulsive or psychotic behavior, every human decision comes down to the choice between two alternatives.","translation":"തികച്ചും ആവേഗമുളവാക്കുന്നതോ മാനസികവുമായ പെരുമാറ്റം ഒഴികെ, എല്ലാ മനുഷ്യ തീരുമാനങ്ങളും രണ്ട് ബദലുകൾക്കിടയിലുള്ള തിരഞ്ഞെടുപ്പിലേക്ക് വരുന്നു.","target_lang":"ml","domain":"general","complexity":"complex"} | |
| {"en":"The next time you buzz down to Moo Foo Goo for fast Chinese, observe yourself while you're poring over the menu.","translation":"അടുത്ത തവണ നിങ്ങൾ ഫാസ്റ്റ് ചൈനീസിനായി മൂ ഫൂ ഗൂവിലേക്ക് പോകുമ്പോൾ, മെനു പരിശോധിക്കുമ്പോൾ സ്വയം നിരീക്ഷിക്കുക.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"The choice might seem, at first, to be of one item out of 26 Cantonese main courses.","translation":"ആരംഭത്തിൽ, 26 കാന്റോണീസ് പ്രധാന കോഴ്സുകളിൽ നിന്ന് ഒരെണ്ണം തിരഞ്ഞെടുക്കുന്നതായി തോന്നാം.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"Not so-the choice, in fact, is between choosing one item and not choosing that one item.","translation":"അങ്ങനെയല്ല-വാസ്തവത്തിൽ, ഒരെണ്ണം തിരഞ്ഞെടുക്കുന്നതിനും അത് തിരഞ്ഞെടുക്കാതിരിക്കുന്നതിനും ഇടയിലാണ് തിരഞ്ഞെടുപ്പ്.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"Your eyes rest on Chicken with Cashews. Naw, too bland.","translation":"നിങ്ങളുടെ കണ്ണുകൾ കശുവണ്ടിയോടുകൂടിയ ചിക്കനിൽ പതിക്കുന്നു. വേണ്ട, വളരെ ലളിതമാണ്.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"That was a test. You slide down to the next item. Chicken with Black Mushrooms.","translation":"അതൊരു പരീക്ഷണമായിരുന്നു. നിങ്ങൾ അടുത്ത ഇനത്തിലേക്ക് നീങ്ങുന്നു. ബ്ലാക്ക് കൂൺ ചേർത്ത ചിക്കൻ.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"Each dish had its moment, poised before the critical eye of your mind, and you turned thumbs up or thumbs down on it, individually.","translation":"ഓരോ വിഭവത്തിനും അതിൻ്റേതായ നിമിഷമുണ്ടായിരുന്നു, നിങ്ങളുടെ മനസ്സിന്റെ വിമർശനാത്മകമായ കണ്ണിനു മുന്നിൽ, നിങ്ങൾ ഓരോന്നിനും തള്ളവിരൽ ഉയർത്തുകയോ താഴ്ത്തുകയോ ചെയ്തു.","target_lang":"ml","domain":"general","complexity":"complex"} | |
| {"en":"Let me give you another example.","translation":"ഞാനൊരു ഉദാഹരണം കൂടി പറയാം.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"Many of life's most complicated decisions come about due to the fact that 99.99867 percent of us are not nudists.","translation":"നമ്മളിൽ 99.99867 ശതമാനം പേരും നഗ്നതാവാദികളല്ലാത്തതുകൊണ്ടാണ് ജീവിതത്തിലെ ഏറ്റവും സങ്കീർണ്ണമായ പല തീരുമാനങ്ങളും ഉണ്ടാകുന്നത്.","target_lang":"ml","domain":"general","complexity":"complex"} | |
| {"en":"You've been there: You're standing in the clothes closet in your underwear, flipping through your rack of pants.","translation":"നിങ്ങൾ അവിടെ ഉണ്ടായിട്ടുണ്ട്: നിങ്ങൾ അടിവസ്ത്രം ധരിച്ച് വസ്ത്രങ്ങൾ സൂക്ഷിക്കുന്ന അറയിൽ നിൽക്കുന്നു, പാന്റ്സിന്റെ റാക്ക് മറിച്ചുനോക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"The tests come thick and fast.","translation":"പരീക്ഷണങ്ങൾ അതിവേഗം വരുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"Read that section again, searching for the general method used.","translation":"ആ ഭാഗം വീണ്ടും വായിക്കുക, ഉപയോഗിച്ച പൊതുവായ രീതി കണ്ടെത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In other words, see what was done and separate the essential principles from any references to a specific base like hex.","translation":"മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, എന്താണ് ചെയ്തതെന്ന് നോക്കുക, കൂടാതെ ഏതെങ്കിലും പ്രത്യേക അടിസ്ഥാനങ്ങളെക്കുറിച്ചുള്ള പരാമർശങ്ങളിൽ നിന്ന് അത്യാവശ്യമായ തത്വങ്ങൾ വേർതിരിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"I'll bet by now you can figure it out without much trouble.","translation":"ഇപ്പോൾ നിങ്ങൾക്ക് അധികം ബുദ്ധിമുട്ടില്ലാതെ ഇത് കണ്ടെത്താൻ കഴിയുമെന്ന് ഞാൻ കരുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A peculiarity of the computer field is that we always begin counting things from 0.","translation":"കമ്പ്യൂട്ടർ മേഖലയുടെ ഒരു പ്രത്യേകത, നമ്മൾ എപ്പോഴും കാര്യങ്ങൾ 0-ൽ നിന്നാണ് എണ്ണാൻ തുടങ്ങുന്നത് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Actually, to call it a peculiarity is unfair; the computer's method is the reasonable one, because 0 is a perfectly good number and should not be discriminated against.","translation":"വാസ്തവത്തിൽ, ഇതിനെ ഒരു പ്രത്യേകത എന്ന് വിളിക്കുന്നത് ശരിയല്ല; കമ്പ്യൂട്ടറിന്റെ രീതിയാണ് ഏറ്റവും ന്യായമായത്, കാരണം 0 ഒരു നല്ല സംഖ്യയാണ്, അതിനെ വേർതിരിക്കുന്നത് ശരിയല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The rift occurred because in our real, physical world, counting things tells us how many things are there, while in the computer world counting things is more generally done to name them.","translation":"നമ്മുടെ യഥാർത്ഥ, ഭൗതിക ലോകത്ത്, കാര്യങ്ങൾ എണ്ണുന്നത് എത്ര കാര്യങ്ങൾ അവിടെയുണ്ടെന്ന് നമ്മോട് പറയുന്നു, അതേസമയം കമ്പ്യൂട്ടർ ലോകത്ത് കാര്യങ്ങൾ എണ്ണുന്നത് സാധാരണയായി അവയ്ക്ക് പേര് നൽകുന്നതിന് വേണ്ടിയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"That is, we need to deal with bit number 0, and then bit number 1, and so on, far more than we need to know how many bits there are.","translation":"അതായത്, ബിറ്റ് നമ്പർ 0 കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്, തുടർന്ന് ബിറ്റ് നമ്പർ 1, അങ്ങനെ എത്ര ബിറ്റുകൾ ഉണ്ട് എന്ന് അറിയേണ്ടതിനേക്കാൾ കൂടുതൽ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is not a quibble, by the way.","translation":"ഇതൊരു തർക്കമല്ല കേട്ടോ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The issue will come up again and again in connection with memory addresses, which as I have said and will say again are the key to understanding assembly language.","translation":"മെമ്മറി വിലാസങ്ങളുമായി ബന്ധപ്പെട്ട് ഈ പ്രശ്നം വീണ്ടും വീണ്ടും വരും, ഞാൻ പറഞ്ഞതുപോലെ വീണ്ടും പറയുകയാണ്, അസംബ്ലി ഭാഷ മനസ്സിലാക്കുന്നതിനുള്ള താക്കോലാണ് ഇത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In programming circles, always begin counting from 0!","translation":"പ്രോഗ്രാമിംഗ് രംഗത്ത്, എപ്പോഴും 0-ൽ നിന്ന് എണ്ണാൻ തുടങ്ങുക!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A practical example of the conflicts this principle can cause grows out of the following question: What year begins the new millennium?","translation":"ഈ തത്വം ഉണ്ടാക്കുന്ന വൈരുദ്ധ്യങ്ങളുടെ ഒരു പ്രായോഗിക ഉദാഹരണം ഇതാ: പുതിയ സഹസ്രാബ്ദം ഏത് വർഷത്തിലാണ് ആരംഭിക്കുന്നത്?","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Most people would intuitively say the year 2000, but technically, the twentieth century will continue until January 1, 2001.","translation":"മിക്ക ആളുകളും 2000 വർഷം എന്ന് പറയും, എന്നാൽ സാങ്കേതികമായി, ഇരുപതാം നൂറ്റാണ്ട് 2001 ജനുവരി 1 വരെ തുടരും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Why? Because there was no year 0.","translation":"എന്തുകൊണ്ട്? കാരണം വർഷം 0 ഉണ്ടായിരുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When historians count the years moving from B. C. to A. D., they go 1B. C. to 1A. D.","translation":"ചരിത്രകാരന്മാർ ബി.സി.യിൽ നിന്ന് എ.ഡി.യിലേക്ക് വർഷങ്ങൾ എണ്ണുമ്പോൾ, അവർ 1 ബി.സി. മുതൽ 1 എ.ഡി. വരെ പോകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Therefore, the first century began with year 1 and ended with year 100.","translation":"അതുകൊണ്ട്, ഒന്നാം നൂറ്റാണ്ട് വർഷം 1 ആരംഭിച്ച് വർഷം 100-ൽ അവസാനിച്ചു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The second century began with year 101 and ended with year 200.","translation":"രണ്ടാം നൂറ്റാണ്ട് 101-ാം വർഷത്തിൽ ആരംഭിച്ച് 200-ൽ അവസാനിച്ചു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"By extending the sequence you can see that the twentieth century began in 1901 and will end in 2000.","translation":"തുടർച്ചയായുള്ളവ വികസിപ്പിക്കുന്നതിലൂടെ ഇരുപതാം നൂറ്റാണ്ട് 1901-ൽ ആരംഭിച്ച് 2000-ൽ അവസാനിക്കുമെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"On the other hand, if we had had the sense to begin counting years in the current era computer style, from year 0, the twentieth century would end at the end of 1999.","translation":"മറുവശത്ത്, ഈ കാലഘട്ടത്തിലെ കമ്പ്യൂട്ടർ ശൈലിയിൽ വർഷം 0 മുതൽ വർഷങ്ങൾ എണ്ണാൻ നമ്മൾക്ക് കഴിഞ്ഞിരുന്നെങ്കിൽ, ഇരുപതാം നൂറ്റാണ്ട് 1999 അവസാനിക്കുമ്പോൾ അവസാനിക്കുമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"My suggestion? Call this the Short Century (which it certainly seems to those of us who have been around for any considerable chunk of it) and begin the Computer Millennium on January 1, 2000.","translation":"എൻ്റെ നിർദ്ദേശം? ഇതിനെ ഹ്രസ്വ നൂറ്റാണ്ട് എന്ന് വിളിക്കുക (അതിൽ കാര്യമായ പങ്കുവഹിച്ച നമ്മെ സംബന്ധിച്ചിടത്തോളം ഇത് തീർച്ചയായും അങ്ങനെയാണ്) കൂടാതെ 2000 ജനുവരി 1-ന് കമ്പ്യൂട്ടർ സഹസ്രാബ്ദം ആരംഭിക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This is a good point to get some practice in converting numbers from binary to decimal and back.","translation":"ബൈനറിയിൽ നിന്ന് ദശാംശത്തിലേക്കും തിരിച്ചും സംഖ്യകൾ പരിവർത്തനം ചെയ്യുന്നതിൽ പരിശീലനം നേടാൻ ഇത് നല്ലൊരു അവസരമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Information enters the computer through a modem peripheral.","translation":"ഒരു മോഡം പെരിഫെറലിലൂടെയാണ് വിവരങ്ങൾ കമ്പ്യൂട്ടറിലേക്ക് പ്രവേശിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The modem then places the assembled byte onto the bus.","translation":"തുടർന്ന്, മോഡം കൂട്ടിച്ചേർത്ത ബൈറ്റ് ബസ്സിൽ സ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The video board then retrieves the byte from the bus.","translation":"പിന്നീട്, വീഡിയോ ബോർഡ് ബസ്സിൽ നിന്ന് ബൈറ്റ് വീണ്ടെടുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Continuous furious communication along the data bus is what accomplishes the work.","translation":"ഡാറ്റാ ബസ്സിലൂടെയുള്ള തുടർച്ചയായ ആശയവിനിമയമാണ് ഈ ജോലി പൂർത്തിയാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Who tells the foreman and crew what to do?","translation":"ഫോർമാനും ക്രൂവിനും എന്ത് ചെയ്യണമെന്ന് ആരാണ് പറയുന്നത്?","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You write a program.","translation":"നിങ്ങൾ ഒരു പ്രോഗ്രാം എഴുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The program is data, and that is the heart of the whole idea of programming.","translation":"പ്രോഗ്രാം ഡാറ്റയാണ്, അതാണ് പ്രോഗ്രാമിംഗിൻ്റെ എല്ലാ ആശയത്തിൻ്റെയും കാതൽ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"These codes are called machine instructions.","translation":"ഈ കോഡുകളെ മെഷീൻ നിർദ്ദേശങ്ങൾ എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Let's take an example or two that is common to all modern CPU chips.","translation":"ആധുനിക CPU ചിപ്പുകളിൽ സാധാരണയായി കാണുന്ന ഒന്നോ രണ്ടോ ഉദാഹരണങ്ങൾ എടുക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Add 1 to register AX.","translation":"AX രജിസ്റ്ററിലേക്ക് 1 ചേർക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Load the value 73H into register DH.","translation":"DH രജിസ്റ്ററിലേക്ക് 73H എന്ന മൂല്യം ലോഡ് ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A computer program is nothing more than a table of these machine instructions.","translation":"ഒരു കമ്പ്യൂട്ടർ പ്രോഗ്രാം, ഈ മെഷീൻ നിർദ്ദേശങ്ങളുടെ ഒരു പട്ടിക മാത്രമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When the CPU is started running, it fetches a double word from memory.","translation":"CPU പ്രവർത്തിക്കാൻ തുടങ്ങുമ്പോൾ, അത് മെമ്മറിയിൽ നിന്ന് ഒരു ഇരട്ട വാക്ക് എടുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU examines the pattern of binary bits contained in the double word.","translation":"CPU, ഇരട്ട വാക്കിൽ അടങ്ങിയിരിക്കുന്ന ബൈനറി ബിറ്റുകളുടെ പാറ്റേൺ പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU works its way through memory.","translation":"CPU മെമ്മറിയിലൂടെ അതിന്റെ വഴി കണ്ടെത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Computer programs are lists of binary machine instructions stored in memory.","translation":"കമ്പ്യൂട്ടർ പ്രോഗ്രാമുകൾ മെമ്മറിയിൽ സംഭരിച്ചിട്ടുള്ള ബൈനറി മെഷീൻ നിർദ്ദേശങ്ങളുടെ ലിസ്റ്റുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"They are binary patterns designed to throw electrical switches.","translation":"അവ വൈദ്യുത സ്വിച്ചുകൾ പ്രവർത്തിപ്പിക്കാൻ രൂപകൽപ്പന ചെയ്ത ബൈനറി പാറ്റേണുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU fetches a byte from memory.","translation":"CPU മെമ്മറിയിൽ നിന്ന് ഒരു ബൈറ്റ് എടുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The CPU can change its course of execution based on the work it has been doing.","translation":"CPU-ക്ക്, അത് ചെയ്യുന്ന ജോലിയെ ആശ്രയിച്ച് എക്സിക്യൂഷൻ്റെ ഗതി മാറ്റാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The computer is a box that follows a plan.","translation":"കമ്പ്യൂട്ടർ ഒരു പ്ലാൻ പിന്തുടരുന്ന ഒരു പെട്ടിയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Early in the year 2000, you could buy memory sticks called SIMMs with 128 megabytes of storage.","translation":"2000-ൻ്റെ തുടക്കത്തിൽ, 128 മെഗാബൈറ്റ് സംഭരണ ശേഷിയുള്ള സിംമ്സ് (SIMMs) എന്ന് വിളിക്കപ്പെടുന്ന മെമ്മറി സ്റ്റിക്കുകൾ നിങ്ങൾക്ക് വാങ്ങാൻ കഴിയുമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"More is better, and we're creating denser memory systems.","translation":"കൂടുതൽ മെച്ചപ്പെട്ടതാണ്, കൂടാതെ കൂടുതൽ സാന്ദ്രമായ മെമ്മറി സംവിധാനങ്ങൾ ഞങ്ങൾ ഉണ്ടാക്കുകയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Some physicists warn that the laws of physics may soon limit the size of transistors.","translation":"ചില ഭൗതികശാസ്ത്രജ്ഞർ മുന്നറിയിപ്പ് നൽകുന്നത് ഭൗതികശാസ്ത്ര നിയമങ്ങൾ ഉടൻ തന്നെ ട്രാൻസിസ്റ്ററുകളുടെ വലുപ്പം പരിമിതപ്പെടുത്തും എന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"At that point, quantum mechanics will start to interfere.","translation":"അവിടെവെച്ച് ക്വാണ്ടം മെക്കാനിക്സ് ഇടപെടാൻ തുടങ്ങും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"We'll find a way around these limitations, but the nature of computer memory may change.","translation":"ഈ പരിമിതികൾക്ക് ഒരു വഴി കണ്ടെത്തും, പക്ഷേ കമ്പ്യൂട്ടർ മെമ്മറിയുടെ സ്വഭാവം മാറിയേക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"My computer has 256 megabytes of electronic memory.","translation":"എൻ്റെ കമ്പ്യൂട്ടറിന് 256 മെഗാബൈറ്റ് ഇലക്ട്രോണിക് മെമ്മറിയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"These chips are called RAM chips, for random-access memory.","translation":"ഈ ചിപ്പുകളെ റാം ചിപ്പുകൾ എന്ന് വിളിക്കുന്നു, ഇത് റാൻഡം-ആക്സസ് മെമ്മറിയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can pick out any of the bits without disturbing the others.","translation":"മറ്റുള്ളവയെ ശല്യപ്പെടുത്താതെ നിങ്ങൾക്ക് ഏതെങ്കിലും ബിറ്റുകൾ തിരഞ്ഞെടുക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Before, memory was stored on magnetic gadgets like rotating drums.","translation":"മുമ്പ്, മെമ്മറി സംഭരിച്ചിരുന്നത് കറങ്ങുന്ന ഡ്രമ്മുകൾ പോലുള്ള കാന്തിക ഗാഡ്ജെറ്റുകളിലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Rotating memory devices are serial-access devices.","translation":"കറങ്ങുന്ന മെമ്മറി ഉപകരണങ്ങൾ സീരിയൽ-ആക്സസ് ഉപകരണങ്ങളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Your hard drive is a serial-access device.","translation":"നിങ്ങളുടെ ഹാർഡ് ഡ്രൈവ് ഒരു സീരിയൽ-ആക്സസ് ഉപകരണമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Inside the chip, each bit is stored in its own memory cell.","translation":"ചിപ്പിനുള്ളിൽ, ഓരോ ബിറ്റും അതിൻ്റേതായ മെമ്മറി സെല്ലിൽ സംഭരിക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Each memory cell has a unique number, its address.","translation":"ഓരോ മെമ്മറി സെല്ലിനും അതിൻ്റേതായ ഒരു അദ്വിതീയ നമ്പർ ഉണ്ട്, അതാണ് അതിന്റെ വിലാസം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can go directly to the bit you want if you have the address.","translation":"വിലാസം കയ്യിലുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ആവശ്യമുള്ള ബിറ്റിലേക്ക് നേരിട്ട് പോകാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The address pins carry a binary address code.","translation":"വിലാസ പിന്നുകൾ ഒരു ബൈനറി വിലാസ കോഡ് വഹിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The data pin will contain a voltage representing the value of the bit.","translation":"ഡാറ്റാ പിന്നിൽ ബിറ്റിൻ്റെ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു വോൾട്ടേജ് ഉണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Chips are graded by how long it takes for data to appear on the data pin.","translation":"ഡാറ്റാ പിന്നിൽ ഡാറ്റ ദൃശ്യമാകാൻ എടുക്കുന്ന സമയമനുസരിച്ചാണ് ചിപ്പുകൾക്ക് ഗ്രേഡ് നൽകുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Memory access time is a limiting factor in a computer's performance.","translation":"മെമ്മറി ആക്സസ് സമയം ഒരു കമ്പ്യൂട്ടറിൻ്റെ പ്രകടനത്തെ പരിമിതപ്പെടുത്തുന്ന ഒരു ഘടകമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A byte is eight bits.","translation":"ഒരു ബൈറ്റ് എന്നാൽ എട്ട് ബിറ്റുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A word is two bytes side by side.","translation":"ഒരു വാക്ക് എന്നാൽ അടുത്തടുത്തുള്ള രണ്ട് ബൈറ്റുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A relocatable object module is a type of binary file.","translation":"റീലൊക്കേറ്റ് ചെയ്യാവുന്ന ഒബ്ജക്റ്റ് മൊഡ്യൂൾ ഒരുതരം ബൈനറി ഫയലാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"For example, a source code file called FOO.ASM would be assembled into an object file called FOO.OBJ.","translation":"ഉദാഹരണത്തിന്, FOO.ASM എന്ന് പേരുള്ള ഒരു സോഴ്സ് കോഡ് ഫയൽ FOO.OBJ എന്ന ഒബ്ജക്റ്റ് ഫയലായി അസംബിൾ ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"OBJ files cannot themselves be run as programs.","translation":"OBJ ഫയലുകൾക്ക് തനിയെ പ്രോഗ്രാമുകളായി പ്രവർത്തിക്കാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"An additional step, called linking, is necessary to turn .OBJ files into executable program files.","translation":".OBJ ഫയലുകളെ എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയലുകളാക്കി മാറ്റാൻ ലിങ്കിംഗ് എന്ന ഒരു അധിക ഘട്ടം ആവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler assembles the various component fragments separately.","translation":"അസംബ്ലർ വിവിധ ഘടക ഭാഗങ്ങളെ പ്രത്യേകം അസംബിൾ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The several resulting .OBJ files are woven together into a single, executable program file.","translation":"തുടർന്ന് ഉണ്ടാകുന്ന .OBJ ഫയലുകൾ ഒരു എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയലായി സംയോജിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"That's why we won't be using a linker initially.","translation":"അതുകൊണ്ടാണ് നമ്മൾ തുടക്കത്തിൽ ഒരു ലിങ്കർ ഉപയോഗിക്കാത്തത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The larger your programs become, however, the more time can be saved by cutting them up into components.","translation":"നിങ്ങളുടെ പ്രോഗ്രാമുകൾ വലുതാകുമ്പോൾ, അവ ഘടകങ്ങളായി വിഭജിക്കുന്നതിലൂടെ കൂടുതൽ സമയം ലാഭിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can move tested, proven routines into separate libraries.","translation":"പരിശോധിച്ച, തെളിയിക്കപ്പെട്ട റൂട്ടീനുകൾ നിങ്ങൾക്ക് പ്രത്യേക ലൈബ്രറികളിലേക്ക് മാറ്റാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Executable Program Files Programs are written to be executed.","translation":"പ്രവർത്തിപ്പിക്കാൻ വേണ്ടി എഴുതുന്നതാണ് എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയലുകൾ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In DOS work, however, there are two types of executable program files: .COM files and .EXE files.","translation":"എന്നാൽ, DOS-ൽ രണ്ട് തരത്തിലുള്ള എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയലുകൾ ഉണ്ട്: .COM ഫയലുകളും .EXE ഫയലുകളും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker program may be seen as a kind of translator program.","translation":"ലിങ്കർ പ്രോഗ്രാമിനെ ഒരുതരം ട്രാൻസ്ലേറ്റർ പ്രോഗ്രാം ആയി കണക്കാക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker would accept, for example, three object code files: FOO.OBJ, BAR.OBJ, and BAS.OBJ.","translation":"ഉദാഹരണത്തിന്, ലിങ്കർ FOO.OBJ, BAR.OBJ, BAS.OBJ എന്നീ മൂന്ന് ഒബ്ജക്റ്റ് കോഡ് ഫയലുകൾ സ്വീകരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"An executable file can be run by typing its name at the DOS prompt and pressing Enter.","translation":"DOS പ്രൊംപ്റ്റിൽ ഫയലിന്റെ പേര് ടൈപ്പ് ചെയ്ത് എന്റർ അമർത്തി എക്സിക്യൂട്ടബിൾ ഫയൽ പ്രവർത്തിപ്പിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"MASM was and remains an enormously popular program.","translation":"MASM വളരെ പ്രചാരമുള്ള ഒരു പ്രോഗ്രാമായിരുന്നു, ഇപ്പോളും അങ്ങനെതന്നെ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The idea of open source software caught fire and caught the imagination of programmers everywhere.","translation":"ഓപ്പൺ സോഴ്സ് സോഫ്റ്റ്വെയർ എന്ന ആശയം ലോകമെമ്പാടുമുള്ള പ്രോഗ്രാമർമാരുടെ ഭാവനയെ ഉണർത്തി.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In open source software, programmers collaborate with dozens or even hundreds of other programmers.","translation":"ഓപ്പൺ സോഴ്സ് സോഫ്റ്റ്വെയറിൽ, പ്രോഗ്രാമർമാർ മറ്റ് നിരവധി പ്രോഗ്രാമർമാരുമായി സഹകരിച്ച് പ്രവർത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The largest and most visible open source project, of course, is the Linux operating system.","translation":"ഏറ്റവും വലിയതും, കൂടുതൽ ശ്രദ്ധിക്കപ്പെട്ടതുമായ ഓപ്പൺ സോഴ്സ് പ്രോജക്റ്റ്, തീർച്ചയായും, Linux ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"I have a couple of chapters on writing assembly language under Linux.","translation":"Linux-ൽ അസംബ്ലി ലാംഗ്വേജ് എഴുതുന്നതിനെക്കുറിച്ച് എനിക്ക് കുറച്ച് അധ്യായങ്ങളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The error messages vary from assembler to assembler.","translation":"അസംബ്ലർ അനുസരിച്ച്, എറർ മെസ്സേജുകൾ വ്യത്യാസപ്പെട്ടിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A DOS file contains some number of bytes, stored in a specific order.","translation":"ഒരു DOS ഫയലിൽ ഒരു നിശ്ചിത എണ്ണം ബൈറ്റുകൾ അടങ്ങിയിരിക്കുന്നു, ഇത് ഒരു പ്രത്യേക ക്രമത്തിൽ സംഭരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Data is stored as little magnetic disturbances on the plastic coating.","translation":"പ്ലാസ്റ്റിക് കോട്ടിംഗിൽ ചെറിയ കാന്തിക തരംഗങ്ങളായി ഡാറ്റ സംഭരിക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The tracks are further divided radially into sectors.","translation":"ട്രാക്കുകൾ പിന്നീട് റേഡിയൽ ആയി സെക്ടറുകളായി വിഭജിക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A sector is the smallest unit of storage that can be read or written at one time.","translation":"ഒരു സെക്ടർ എന്നത് ഒരേ സമയം വായിക്കാനോ എഴുതാനോ കഴിയുന്ന ഏറ്റവും ചെറിയ സംഭരണ യൂണിറ്റാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The read/write head is mounted on a sliding shaft that is controlled by a solenoid mechanism.","translation":"റീഡ്/റൈറ്റ് ഹെഡ് ഒരു സോളിനോയിഡ് മെക്കാനിസം നിയന്ത്രിക്കുന്ന ഒരു സ്ലൈഡിംഗ് ഷാഫ്റ്റിലാണ് സ്ഥാപിച്ചിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Programs can hand sectors of data to DOS, one at a time.","translation":"പ്രോഗ്രാമുകൾക്ക് ഡാറ്റയുടെ സെക്ടറുകൾ DOS-ലേക്ക് ഒന്നൊന്നായി കൈമാറാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When you ask for sector 0 of your file, DOS looks up its location.","translation":"നിങ്ങൾ നിങ്ങളുടെ ഫയലിന്റെ സെക്ടർ 0 ആവശ്യപ്പെടുമ്പോൾ, DOS അതിന്റെ സ്ഥാനം തിരയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The data stored in a file are just binary bytes and can be anything at all.","translation":"ഒരു ഫയലിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റ ബൈനറി ബൈറ്റുകളാണ്, അത് എന്തും ആകാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Files like this, where there are no restrictions on the contents of a file, are called binary files.","translation":"ഒരു ഫയലിന്റെ ഉള്ളടക്കത്തിൽ നിയന്ത്രണങ്ങളില്ലാത്ത ഇത്തരം ഫയലുകളെ ബൈനറി ഫയലുകൾ എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"If you've ever tried to use the DOS TYPE command to display a binary file, you've seen some odd things indeed.","translation":"ഒരു ബൈനറി ഫയൽ പ്രദർശിപ്പിക്കുന്നതിന് നിങ്ങൾ DOS TYPE കമാൻഡ് ഉപയോഗിക്കാൻ ശ്രമിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ചില വിചിത്രമായ കാര്യങ്ങൾ കണ്ടിട്ടുണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"These are text files, because they contain the letters, digits, and symbols of which printed human information (text) is composed.","translation":"ഇവ ടെക്സ്റ്റ് ഫയലുകളാണ്, കാരണം അവ അച്ചടിച്ച വിവരങ്ങൾ (ടെക്സ്റ്റ്) ഉണ്ടാക്കുന്ന അക്ഷരങ്ങൾ, അക്കങ്ങൾ, ചിഹ്നങ്ങൾ എന്നിവ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A line in a text file is defined not so much by what it contains as by how it ends.","translation":"ഒരു ടെക്സ്റ്റ് ഫയലിലെ ഒരു വരി അതിൽ എന്താണുള്ളത് എന്നതിനേക്കാൾ, അത് എങ്ങനെ അവസാനിക്കുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A special series of invisible characters called an end-of-line (EOL) marker tags the end of a line.","translation":"എൻഡ്-ഓഫ്-ലൈൻ (EOL) മാർക്കർ എന്ന് വിളിക്കപ്പെടുന്ന പ്രത്യേക ശ്രേണിയിലുള്ള അദൃശ്യ പ്രതീകങ്ങൾ ഒരു വരിയുടെ അവസാനം അടയാളപ്പെടുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The EOL marker for DOS is not one character but two: the carriage return character followed by the linefeed character.","translation":"DOS-നുള്ള EOL മാർക്കർ ഒന്നല്ല, രണ്ട് പ്രതീകങ്ങളാണ്: കാരിയേജ് റിട്ടേൺ പ്രതീകവും തുടർന്ന് ലൈൻഫീഡ് പ്രതീകവും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"With Linux things are different: a single LF, without a partner CR.","translation":"Linux-ൽ കാര്യങ്ങൾ വ്യത്യസ്തമാണ്: ഒരു CR പങ്കാളിയില്ലാത്ത ഒരു LF.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It was a separate mechanical operation to return the typing carriage to the left margin of the paper.","translation":"ടൈപ്പിംഗ് കാരിയേജ് പേപ്പറിന്റെ ഇടത് മാർജിനിലേക്ക് തിരികെ കൊണ്ടുവരുന്നത് ഒരു പ്രത്യേക മെക്കാനിക്കൽ പ്രവർത്തനമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The assembler's most important job is to read lines from the source code file and write machine instructions to an object code file.","translation":"അസംബ്ലറിൻ്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ജോലി സോഴ്സ് കോഡ് ഫയലിൽ നിന്ന് വരികൾ വായിച്ച് മെഷീൻ നിർദ്ദേശങ്ങൾ ഒരു ഒബ്ജക്റ്റ് കോഡ് ഫയലിലേക്ക് എഴുതുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"To the right of each instruction is some information starting with a semicolon.","translation":"ഓരോ നിർദ്ദേശത്തിനും വലതുവശത്ത് അർദ്ധവിരാമത്തിൽ ആരംഭിക്കുന്ന ചില വിവരങ്ങൾ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"My own recommendation is that every instruction in your source code files should have a comment to its right.","translation":"നിങ്ങളുടെ സോഴ്സ് കോഡ് ഫയലുകളിലെ എല്ലാ നിർദ്ദേശങ്ങൾക്കും അതിൻ്റെ വലതുവശത്ത് ഒരു അഭിപ്രായം ഉണ്ടായിരിക്കണം എന്നാണ് എൻ്റെ സ്വന്തം ശുപാർശ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Without context, assembly language starts to turn into what we call \"write-only\" code.","translation":"സന്ദർഭം ഇല്ലാതെ, അസംബ്ലി ഭാഷ നമ്മൾ ","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In other words, until you understand why you're getting a warning message, treat it as though it were an error message.","translation":"മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നിങ്ങൾ ഒരു മുന്നറിയിപ്പ് സന്ദേശം എന്തുകൊണ്ടാണ് ലഭിക്കുന്നതെന്ന് മനസ്സിലാക്കാത്ത പക്ഷം, അതൊരു പിശക് സന്ദേശമായി കണക്കാക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You must edit your source code file, assemble it, and return to the editor to fix errors until the assembler spots no further errors.","translation":"നിങ്ങൾ നിങ്ങളുടെ സോഴ്സ് കോഡ് ഫയൽ എഡിറ്റ് ചെയ്യണം, അത് അസംബിൾ ചെയ്യണം, തുടർന്ന് അസംബ്ലർ കൂടുതൽ പിശകുകൾ കണ്ടെത്തുന്നത് വരെ തിരുത്തലുകൾക്കായി എഡിറ്ററിലേക്ക് മടങ്ങുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The first part of the assembly language development process is a loop.","translation":"അസംബ്ലി ഭാഷാ വികസന പ്രക്രിയയുടെ ആദ്യ ഭാഗം ഒരു ലൂപ്പാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You cannot continue until the assembler gives your source code file a clean bill of health.","translation":"അസംബ്ലർ നിങ്ങളുടെ സോഴ്സ് കോഡ് ഫയലിന് ഒരു ശുദ്ധീകരണ സർട്ടിഫിക്കറ്റ് നൽകാതെ നിങ്ങൾക്ക് തുടരാനാവില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When no further errors are found, the assembler will write an . OBJ file to disk.","translation":"കൂടുതൽ പിശകുകൾ കണ്ടെത്താത്തപ്പോൾ, അസംബ്ലർ ഒരു .OBJ ഫയൽ ഡിസ്കിലേക്ക് എഴുതും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The linker performs a number of operations on the . OBJ file.","translation":"ലിങ്കർ .OBJ ഫയലിൽ നിരവധി പ്രവർത്തനങ്ങൾ നടത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The most obvious task the linker does is to weave several . OBJ files into a single . EXE executable program file.","translation":"ലിങ്കർ ചെയ്യുന്ന ഏറ്റവും വ്യക്തമായ കാര്യം നിരവധി .OBJ ഫയലുകൾ ഒരു .EXE എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയലിലേക്ക് സംയോജിപ്പിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Creating an assembly language program from multiple . ASM files is called modular assembly.","translation":"ഒന്നിലധികം .ASM ഫയലുകളിൽ നിന്ന് ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാം ഉണ്ടാക്കുന്നതിനെ മോഡുലാർ അസംബ്ലി എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One of two major reasons is size.","translation":"രണ്ട് പ്രധാന കാരണങ്ങളിലൊന്ന് വലുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A middling assembly language application might be 50,000 lines long.","translation":"ഒരു ഇടത്തരം അസംബ്ലി ഭാഷാ ആപ്ലിക്കേഷൻ 50,000 വരികൾ വരെ ഉണ്ടാകാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The other reason is to avoid assembling completed portions of the program every time any part of the program is assembled.","translation":"പ്രോഗ്രാമിന്റെ ഏതെങ്കിലും ഭാഗം അസംബിൾ ചെയ്യുമ്പോഴെല്ലാം പ്രോഗ്രാമിന്റെ പൂർത്തിയായ ഭാഗങ്ങൾ വീണ്ടും അസംബിൾ ചെയ്യുന്നത് ഒഴിവാക്കുക എന്നതാണ് മറ്റൊരു കാരണം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Once you write and perfect a procedure, you can tuck it away in an . ASM file with other completed procedures.","translation":"നിങ്ങൾ ഒരു നടപടിക്രമം എഴുതി പൂർത്തിയാക്കിക്കഴിഞ്ഞാൽ, മറ്റ് പൂർണ്ണമായ നടപടിക്രമങ്ങൾക്കൊപ്പം ഒരു .ASM ഫയലിൽ സൂക്ഷിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The alternative is to waste time by reassembling perfected source code over and over again every time you assemble the main portion of the program.","translation":"പ്രധാന പ്രോഗ്രാം ഭാഗം അസംബിൾ ചെയ്യുമ്പോഴെല്ലാം, പൂർണ്ണമായ സോഴ്സ് കോഡ് വീണ്ടും വീണ്ടും അസംബിൾ ചെയ്യുന്നതിലൂടെ സമയം പാഴാക്കുക എന്നതാണ് ഇതിന്റെ മറ്റൊരു വശം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The single . EXE file that the linker writes to disk contains the machine instructions from all of the . OBJ files handed to the linker when then linker is invoked.","translation":"ലിങ്കർ പ്രവർത്തിക്കുമ്പോൾ ലിങ്കറിലേക്ക് നൽകുന്ന എല്ലാ .OBJ ഫയലുകളിൽ നിന്നുമുള്ള മെഷീൻ നിർദ്ദേശങ്ങൾ ലിങ്കർ ഡിസ്കിലേക്ക് എഴുതുന്ന ഒരൊറ്റ .EXE ഫയലിൽ അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A very important bonus is that some of the procedures in an . OBJ module may be used in a future assembly language program that hasn't even been begun yet.","translation":"വളരെ പ്രധാനപ്പെട്ട ഒരു ബോണസ് എന്തെന്നാൽ, ഒരു .OBJ മൊഡ്യൂളിലെ ചില നടപടിക്രമങ്ങൾ ഇതുവരെ ആരംഭിക്കാത്ത ഭാവിയിലെ അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിൽ ഉപയോഗിച്ചേക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Creating such libraries of \"toolkit\" procedures can be an extraordinarily effective way to save time by reusing code over and over again, without even passing it through the assembler again!","translation":"\"ടൂൾകിറ്റ്\" നടപടിക്രമങ്ങളുടെ അത്തരം ലൈബ്രറികൾ ഉണ്ടാക്കുന്നത്, കോഡ് വീണ്ടും വീണ്ടും ഉപയോഗിക്കുന്നതിലൂടെ സമയം ലാഭിക്കാൻ വളരെ ഫലപ്രദമായ ഒരു മാർഗ്ഗമാണ്, അസംബ്ലറിലൂടെ വീണ്ടും കടന്നുപോകാതെ തന്നെ!","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"More recent assemblers such as NASM can often take up some of the work that a linker normally does and allow you to create simple executable programs from single . ASM files.","translation":"NASM പോലുള്ള പുതിയ അസംബ്ലറുകൾക്ക് സാധാരണയായി ഒരു ലിങ്കർ ചെയ്യുന്ന ചില ജോലികൾ ഏറ്റെടുക്കാനും, സിംഗിൾ .ASM ഫയലുകളിൽ നിന്ന് ലളിതമായ എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമുകൾ ഉണ്ടാക്കാൻ നിങ്ങളെ അനുവദിക്കാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"But keep in mind that to produce an executable . EXE file from multiple assembly language source code files, you must invoke the linker.","translation":"എന്നാൽ ഒന്നിലധികം അസംബ്ലി ഭാഷാ സോഴ്സ് കോഡ് ഫയലുകളിൽ നിന്ന് ഒരു എക്സിക്യൂട്ടബിൾ .EXE ഫയൽ ഉണ്ടാക്കാൻ, നിങ്ങൾ ലിങ്കർ പ്രവർത്തിപ്പിക്കണം എന്ന് ഓർമ്മിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Invoking the linker is again done from the DOS command line.","translation":"ലിങ്കർ വീണ്ടും പ്രവർത്തിപ്പിക്കുന്നത് DOS കമാൻഡ് ലൈനിൽ നിന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Linker errors are subtler than assembler errors and are usually harder to find.","translation":"ലിങ്കർ പിശകുകൾ അസംബ്ലർ പിശകുകളേക്കാൾ സൂക്ഷ്മവും സാധാരണയായി കണ്ടെത്താൻ ബുദ്ധിമുട്ടുള്ളതുമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Anything after that final 0AH value is garbage in memory and not part of the file!","translation":"അവസാനത്തെ 0AH മൂല്യത്തിന് ശേഷമുള്ള എന്തും മെമ്മറിയിലെ മാലിന്യമാണ്, ഫയലിന്റെ ഭാഗമല്ല!","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Some very old DOS text editors appended a single invisible byte at the end of every text file they wrote to disk.","translation":"ചില പഴയ DOS ടെക്സ്റ്റ് എഡിറ്റർമാർ അവർ ഡിസ്കിലേക്ക് എഴുതിയ എല്ലാ ടെക്സ്റ്റ് ഫയലിന്റെയും അവസാനം ഒരു അദൃശ്യ ബൈറ്റ് ചേർക്കുമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This byte, 1AH, was intended as a marker to show you very clearly where the end of the file was.","translation":"ഈ ബൈറ്റ്, 1AH, ഫയലിന്റെ അവസാനം എവിടെയാണെന്ന് വളരെ വ്യക്തമായി കാണിക്കാൻ ഉദ്ദേശിച്ചുള്ളതായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Some of these text editors are still kicking around, and it's possible that you have one.","translation":"ഇവയിൽ ചില ടെക്സ്റ്റ് എഡിറ്റർമാർ ഇപ്പോഴും നിലവിലുണ്ട്, ഒരുപക്ഷേ നിങ്ങളുടേതായി ഒരെണ്ണം ഉണ്ടാകാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"To see if you do, type in a simple sentence like \"Where will it all end?\" and save to disk.","translation":"നിങ്ങൾക്കുണ്ടോയെന്ന് അറിയാൻ, \"ഇതെല്ലാം എവിടെ അവസാനിക്കും?\" എന്നതുപോലെയുള്ള ഒരു ലളിതമായ വാക്യം ടൈപ്പ് ചെയ്ത് ഡിസ്കിൽ സേവ് ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The 1AH marker is a holdover from even more ancient times, from the CP/M operating system.","translation":"1AH മാർക്കർ, CP/M ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ നിന്നുള്ള, വളരെ പഴയ കാലത്തെ ഒരു അവശിഷ്ടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The precise byte where the file's data ended within the final block was unknown to CP/M.","translation":"അവസാന ബ്ലോക്കിൽ ഫയലിന്റെ ഡാറ്റ അവസാനിക്കുന്ന കൃത്യമായ ബൈറ്റ് CP/M-ന് അജ്ഞാതമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"There's a file on your CD-ROM, OLDSAM. TXT, which was created with such a text editor and has the final 1AH marker.","translation":"നിങ്ങളുടെ CD-ROM-ൽ OLDSAM. TXT എന്നൊരു ഫയൽ ഉണ്ട്, അത് അത്തരത്തിലുള്ള ഒരു ടെക്സ്റ്റ് എഡിറ്റർ ഉപയോഗിച്ച് ഉണ്ടാക്കിയതാണ്, അതിൽ അവസാനത്തെ 1AH മാർക്കർ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Note the time stamp on OLDSAM. TXT!","translation":"OLDSAM. TXT-ലെ ടൈം സ്റ്റാമ്പ് ശ്രദ്ധിക്കുക!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"OLDSAM is otherwise identical to SAM. TXT.","translation":"മറ്റുള്ള രീതിയിൽ OLDSAM, SAM. TXT-ന് സമാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Note that when you do a DOS DIR command on the directory containing the two files, that OLDSAM. TXT is 20 bytes long.","translation":"രണ്ട് ഫയലുകളും അടങ്ങിയ ഡയറക്ടറിയിൽ നിങ്ങൾ ഒരു DOS DIR കമാൻഡ് ചെയ്യുമ്പോൾ, OLDSAM. TXT 20 ബൈറ്റുകൾ നീളമുള്ളതാണെന്ന് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Most of the time, memory garbage is not entirely random, but instead may be part of the code or data left over from the last program.","translation":"മിക്കവാറും സമയങ്ങളിൽ, മെമ്മറി മാലിന്യം പൂർണ്ണമായും ക്രമരഹിതമല്ല, മറിച്ച് അവസാനത്തെ പ്രോഗ്രാമിൽ നിന്ന് അവശേഷിക്കുന്ന കോഡിന്റെയോ ഡാറ്റയുടെയോ ഭാഗമായിരിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You can safely ignore memory garbage, but should know what it is and why it appears in your hex dumps.","translation":"മെമ്മറി മാലിന്യം നിങ്ങൾക്ക് സുരക്ഷിതമായി അവഗണിക്കാം, എന്നാൽ അത് എന്താണെന്നും നിങ്ങളുടെ ഹെക്സ് ഡംപുകളിൽ എന്തുകൊണ്ട് ദൃശ്യമാകുന്നു എന്നും നിങ്ങൾ അറിയണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You might occasionally see recognizable data strings from other programs in memory garbage and wonder how they got into your current program.","translation":"മെമ്മറി മാലിന്യത്തിൽ മറ്റ് പ്രോഗ്രാമുകളിൽ നിന്നുള്ള തിരിച്ചറിയാൻ കഴിയുന്ന ഡാറ്റാ സ്ട്രിംഗുകൾ നിങ്ങൾ ഇടയ്ക്കിടെ കണ്ടേക്കാം, അത് എങ്ങനെ നിങ്ങളുടെ നിലവിലെ പ്രോഗ്രാമിൽ എത്തി എന്ന് ആശ്ചര്യപ്പെടാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Note well: They didn't get into your current program.","translation":"ശ്രദ്ധിക്കുക: അവ നിങ്ങളുടെ നിലവിലെ പ്രോഗ്രാമിൽ എത്തിയിട്ടില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"They were just there, and now show through beyond the end of the file you last loaded under DEBUG.","translation":"അവ അവിടെ ഉണ്ടായിരുന്നു, ഇപ്പോൾ നിങ്ങൾ DEBUG-ൽ അവസാനമായി ലോഡ് ചെയ്ത ഫയലിന്റെ അവസാനം വരെ കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Knowing where legitimate information ends and where garbage begins is always important and not generally as clear-cut as it is here.","translation":"legitimate വിവരങ്ങൾ എവിടെ അവസാനിക്കുന്നു, മാലിന്യം എവിടെ ആരംഭിക്കുന്നു എന്ന് അറിയുന്നത് എപ്പോഴും പ്രധാനമാണ്, ഇവിടെയുള്ളത്ര വ്യക്തമായി ഇത് സാധാരണയായിരിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"DEBUG can easily change bytes in memory, whether they are part of a file loaded from disk or not.","translation":"മെമ്മറിയിലെ ബൈറ്റുകൾ DEBUG-ന് എളുപ്പത്തിൽ മാറ്റാൻ കഴിയും, അവ ഡിസ്കിൽ നിന്ന് ലോഡ് ചെയ്ത ഫയലിന്റെ ഭാഗമാണോ അല്ലയോ എന്നത് പ്രശ്നമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The DEBUG command to change bytes is the E command.","translation":"ബൈറ്റുകൾ മാറ്റാനുള്ള DEBUG കമാൻഡ് E കമാൻഡ് ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can use the E command to change some of the data in SAM. TXT.","translation":"SAM. TXT-ലെ ചില ഡാറ്റകൾ മാറ്റാൻ നിങ്ങൾക്ക് E കമാൻഡ് ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"I recommend that you place the directory containing NASM-IDE on your DOS path.","translation":"NASM-IDE അടങ്ങിയ ഡയറക്ടറി നിങ്ങളുടെ DOS പാതയിൽ സ്ഥാപിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"That way, no matter where you are on your hard drive, you can type \"NASMIDE\" and NASM-IDE will come up, ready for work.","translation":"അങ്ങനെ, നിങ്ങളുടെ ഹാർഡ് ഡ്രൈവിൽ എവിടെയായിരുന്നാലും, നിങ്ങൾക്ക് \"NASMIDE\" എന്ന് ടൈപ്പ് ചെയ്യാം, തുടർന്ന് NASM-IDE പ്രവർത്തിക്കാൻ തയ്യാറായി വരും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When you bring up NASM-IDE using the preceding command line, what you'll see should look a lot like Figure 5.1.","translation":"മുമ്പത്തെ കമാൻഡ് ലൈൻ ഉപയോഗിച്ച് NASM-IDE കൊണ്ടുവരുമ്പോൾ, നിങ്ങൾ കാണുന്നത് ചിത്രം 5.1-ന് സമാനമായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE consists of an empty space (with a texture to fill it, indicating that it's empty) in which you can open windows containing information.","translation":"വിവരങ്ങൾ അടങ്ങിയ വിൻഡോകൾ തുറക്കാൻ കഴിയുന്ന ശൂന്യമായ ഇടമാണ് NASM-IDE-ൽ ഉള്ളത് (അതൊഴിവുള്ളതാണെന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഘടനയോടുകൂടി).","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"At the top of the screen is a menu bar.","translation":"സ്ക്രീനിന്റെ മുകളിൽ ഒരു മെനു ബാറുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"At the bottom of the screen is a prompt bar.","translation":"സ്ക്രീനിന്റെ താഴെയായി ഒരു പ്രോംപ്റ്റ് ബാറുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The menu bar provides several menus of options that you can pull down (either from the keyboard or with the mouse) to accomplish the various things that NASM-IDE can do.","translation":"NASM-IDE-ക്ക് ചെയ്യാൻ കഴിയുന്ന വിവിധ കാര്യങ്ങൾ ചെയ്യുന്നതിന്, കീബോർഡിൽ നിന്നോ മൗസിൽ നിന്നോ താഴേക്ക് വലിക്കാൻ കഴിയുന്ന നിരവധി ഓപ്ഷനുകളുടെ മെനുകൾ മെനു ബാറിൽ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The prompt bar gives you terse reminders of the most important commands that you can issue via the function keys and various hot keys.","translation":"പ്രധാനപ്പെട്ട കമാൻഡുകളെക്കുറിച്ചുള്ള ഹ്രസ്വമായ ഓർമ്മപ്പെടുത്തലുകൾ ഫംഗ്ഷൻ കീകൾ വഴിയും വിവിധ ഹോട്ട് കീകൾ വഴിയും പ്രോംപ്റ്റ് ബാർ നിങ്ങൾക്ക് നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Square in the middle of the screen is an edit window containing the file you opened when you invoked NASM-IDE.","translation":"സ്ക്രീനിന്റെ മധ്യഭാഗത്തായി, NASM-IDE പ്രവർത്തിപ്പിക്കുമ്പോൾ നിങ്ങൾ തുറന്ന ഫയൽ അടങ്ങിയ ഒരു എഡിറ്റ് വിൻഡോ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There isn't a lot of installing or configuring to be done with either NASMIDE or NASM itself.","translation":"NASMIDE അല്ലെങ്കിൽ NASM എന്നിവ ഇൻസ്റ്റാൾ ചെയ്യാനോ കോൺഫിഗർ ചെയ്യാനോ അധികം കാര്യങ്ങളില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"However, you need to copy that directory to a place on your hard drive, because you cannot write files to the CD-ROM.","translation":"എങ്കിലും, നിങ്ങൾ ആ ഡയറക്ടറി നിങ്ങളുടെ ഹാർഡ് ഡ്രൈവിലെവിടെയെങ്കിലും പകർത്തിയിരിക്കണം, കാരണം നിങ്ങൾക്ക് CD-ROM-ലേക്ക് ഫയലുകൾ എഴുതാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can drag the ASM directory from the CD-ROM to one of your hard drive units using Windows Explorer, and all of the subdirectories under ASM will come along.","translation":"വിൻഡോസ് എക്സ്പ്ലോറർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ASM ഡയറക്ടറി CD-ROM-ൽ നിന്ന് നിങ്ങളുടെ ഹാർഡ് ഡ്രൈവിലേക്ക് വലിച്ചിടാം, കൂടാതെ ASM-ന് കീഴിലുള്ള എല്ലാ ഉപഡയറക്ടറികളും ഇതിനൊപ്പം വരും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Once you get NASM-IDE running, you need to do one essential piece of configuration before you can use it: You must tell it the exact path where the NASM executable file resides.","translation":"NASM-IDE പ്രവർത്തിച്ചു തുടങ്ങിയാൽ, ഇത് ഉപയോഗിക്കുന്നതിന് മുമ്പ് നിങ്ങൾ ഒരു പ്രധാന കോൺഫിഗറേഷൻ ചെയ്യേണ്ടതുണ്ട്: NASM എക്സിക്യൂട്ടബിൾ ഫയൽ എവിടെയാണോ ഉള്ളത്, ആ കൃത്യമായ പാത നിങ്ങൾ ഇതിനെ അറിയിക്കണം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"I recommend making ASM a subdirectory on the root of one of your hard drives; for example, C:\\ASM rather than C:\\programming\\ASM.","translation":"നിങ്ങളുടെ ഹാർഡ് ഡ്രൈവുകളിലൊന്നിൽ ASM ഒരു ഉപഡയറക്ടറിയായി ഉണ്ടാക്കുന്നതാണ് നല്ലത്; ഉദാഹരണത്തിന്, C:\\programming\\ASM എന്നതിനേക്കാൾ C:\\ASM.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Choose one and copy the ASM directory from your CD-ROM to your hard drive.","translation":"ഒന്ന് തിരഞ്ഞെടുത്ത് നിങ്ങളുടെ CD-ROM-ൽ നിന്ന് ASM ഡയറക്ടറി നിങ്ങളുടെ ഹാർഡ് ഡ്രൈവിലേക്ക് പകർത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Then bring up NASM-IDE and pull down the Options menu.","translation":"തുടർന്ന് NASM-IDE തുറന്ന് ഓപ്ഷൻസ് മെനു താഴേക്ക് കൊണ്ടുവരിക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Select the Options|Assembler item by either highlighting it and pressing Enter, or double-clicking on it with your mouse.","translation":"ഓപ്ഷൻസ്|അസംബ്ലർ എന്ന ഇനം ഹൈലൈറ്റ് ചെയ്ത് എന്റർ അമർത്തുകയോ അല്ലെങ്കിൽ മൗസ് ഉപയോഗിച്ച് ഡബിൾ ക്ലിക്ക് ചെയ്യുകയോ ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A dialog box will appear.","translation":"ഒരു ഡയലോഗ് ബോക്സ് ദൃശ്യമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You shouldn't change anything in this box except for one item: the edit line labeled NASM Location.","translation":"NASM ലൊക്കേഷൻ എന്ന് ലേബൽ ചെയ്ത എഡിറ്റ് ലൈൻ ഒഴികെ ഈ ബോക്സിൽ നിങ്ങൾ മറ്റൊന്നും മാറ്റരുത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When the dialog box appears, this line will be blank.","translation":"ഡയലോഗ് ബോക്സ് ദൃശ്യമാകുമ്പോൾ, ഈ വരി ശൂന്യമായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Fixing it, however, is easy.","translation":"എങ്കിലും, ഇത് ശരിയാക്കുന്നത് എളുപ്പമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Assembly language is nothing if not tricky.","translation":"അസംബ്ലി ഭാഷ സൂത്രശാലിയല്ലെങ്കിൽ ഒന്നുമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You have to be able to identify errors based on what you've written.","translation":"നിങ്ങൾ എഴുതിയതിനെ അടിസ്ഥാനമാക്കി തെറ്റുകൾ തിരിച്ചറിയാൻ നിങ്ങൾക്ക് കഴിയണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE has the error dead to rights.","translation":"NASM-IDE-ക്ക് തെറ്റ് കൃത്യമായി മനസ്സിലായിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can fix the error by nuking the whole line with a quick Ctrl-Y.","translation":"Ctrl-Y ഉപയോഗിച്ച് ആ വരി പൂർണ്ണമായും നീക്കം ചെയ്തുകൊണ്ട് നിങ്ങൾക്ക് തെറ്റ് തിരുത്താനാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Every time you assemble, the error information message will appear.","translation":"എല്ലാ തവണയും നിങ്ങൾ അസംബിൾ ചെയ്യുമ്പോൾ, പിശക് വിവര സന്ദേശം ദൃശ്യമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can run the EAT2. COM file from the DOS prompt.","translation":"DOS പ്രൊംപ്റ്റിൽ നിന്ന് EAT2.COM ഫയൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"NASM-IDE can run your executable program file for you, right from inside NASM-IDE.","translation":"NASM-IDE-യിൽ നിന്ന് തന്നെ നിങ്ങളുടെ എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയൽ പ്രവർത്തിപ്പിക്കാൻ NASM-IDE-ക്ക് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM-IDE will go away for a moment, and instead you'll see a blank DOS screen.","translation":"NASM-IDE അൽപനേരത്തേക്ക് അപ്രത്യക്ഷമാകും, പകരം നിങ്ങൾ ഒരു ശൂന്യമായ DOS സ്ക്രീൻ കാണും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Getting back to NASM-IDE is no big deal.","translation":"NASM-IDE-യിലേക്ക് തിരിച്ചു വരുന്നത് വലിയ കാര്യമല്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"People who have read earlier editions of this book may notice a remarkable resemblance.","translation":"ഈ പുസ്തകത്തിന്റെ പഴയ പതിപ്പുകൾ വായിച്ചവർ ഒരു ശ്രദ്ധേയമായ സാമ്യം ശ്രദ്ധിച്ചേക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Individual lines within an edit file are limited to 254 characters.","translation":"ഒരു എഡിറ്റ് ഫയലിനുള്ളിലെ ഓരോ വരിയും 254 അക്ഷരങ്ങളിൽ പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Loading a file with longer lines will cause the editor to insert hyphens.","translation":"വലിയ വരികളുള്ള ഒരു ഫയൽ ലോഡ് ചെയ്യുന്നത് എഡിറ്റർ ഹൈഫനുകൾ ചേർക്കാൻ കാരണമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You'll get an error box if you try to type past the 254-character point.","translation":"254-ആമത്തെ അക്ഷരത്തിനു ശേഷം ടൈപ്പ് ചെയ്യാൻ ശ്രമിച്ചാൽ നിങ്ങൾക്ക് ഒരു പിശക് ബോക്സ് ലഭിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It's useful to know that you can load more than one text file into NASM-IDE's environment at once.","translation":"ഒന്നിലധികം ടെക്സ്റ്റ് ഫയലുകൾ ഒരേ സമയം NASM-IDE-യുടെ പരിതസ്ഥിതിയിലേക്ക് ലോഡ് ചെയ്യാൻ കഴിയുമെന്നത് അറിയുന്നത് ഉപകാരപ്രദമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Opening a file in an edit window from inside NASM-IDE is done using either the menus or hotkeys.","translation":"NASM-IDE-യിൽ നിന്ന് ഒരു എഡിറ്റ് വിൻഡോയിൽ ഒരു ഫയൽ തുറക്കുന്നത് മെനുകൾ അല്ലെങ്കിൽ ഹോട്ട്കീകൾ ഉപയോഗിച്ചാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Selecting the File|Open menu item with the mouse will bring up a dialog box.","translation":"File|Open മെനു ഇനം മൗസ് ഉപയോഗിച്ച് തിരഞ്ഞെടുക്കുന്നത് ഒരു ഡയലോഗ് ബോക്സ് കൊണ്ടുവരും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The dialog is one of the more complex ones you'll encounter in using NASM-IDE.","translation":"NASM-IDE ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾ കണ്ടെത്തുന്ന ഏറ്റവും സങ്കീർണ്ണമായ ഒന്നാണ് ഈ ഡയലോഗ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You can navigate through a DOS directory structure using the dialog box.","translation":"ഡയലോഗ് ബോക്സ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു DOS ഡയറക്ടറി ഘടനയിലൂടെ നാവിഗേറ്റ് ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you double-click on ..\\, you will move up one level in the directory hierarchy.","translation":"..\\-ൽ ഡബിൾ-ക്ലിക്ക് ചെയ്താൽ, നിങ്ങൾ ഡയറക്ടറി ശ്രേണിയിൽ ഒരു ലെവൽ മുകളിലേക്ക് നീങ്ങും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Copy is useful when you have some standard text construction that you need to use several times within the same text file.","translation":"ഒരേ ടെക്സ്റ്റ് ഫയലിനുള്ളിൽ തന്നെ പലതവണ ഉപയോഗിക്കേണ്ട ചില സാധാരണ ടെക്സ്റ്റ് ഉണ്ടാക്കുമ്പോൾ പകർപ്പ് ഉപയോഗപ്രദമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Simply put the cursor where the first character of the copied text must go, and then issue the Paste command.","translation":"പകർത്തുന്ന ടെക്സ്റ്റിന്റെ ആദ്യ അക്ഷരം എവിടെയാണോ വേണ്ടത് അവിടെ കേഴ്സർ വെച്ച് പേസ്റ്റ് കമാൻഡ് നൽകുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Moving a block of text is similar to copying a block of text.","translation":"ഒരു ടെക്സ്റ്റ് ബ്ലോക്ക് നീക്കുന്നത് ഒരു ടെക്സ്റ്റ് ബ്ലോക്ക് പകർപ്പുവരുത്തുന്നതിന് സമാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Cutting the block is done by highlighting a block of text and then pressing Shift-Del.","translation":"ഒരു ടെക്സ്റ്റ് ബ്ലോക്ക് ഹൈലൈറ്റ് ചെയ്ത ശേഷം Shift-Del അമർത്തി ബ്ലോക്ക് കട്ട് ചെയ്യാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"All of the clipboard-related commands may also be given from the Edit menu.","translation":"എഡിറ്റ് മെനുവിൽ നിന്നും ക്ലിപ്ബോർഡുമായി ബന്ധപ്പെട്ട എല്ലാ കമാൻഡുകളും നൽകാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Once you mark a block by highlighting it, you can pull down the Edit menu and select the Cut, Copy, or Clear items to act on the marked block.","translation":"ഹൈലൈറ്റ് ചെയ്തുകൊണ്ട് ഒരു ബ്ലോക്ക് അടയാളപ്പെടുത്തിയ ശേഷം, എഡിറ്റ് മെനു തുറന്ന് കട്ട്, കോപ്പി അല്ലെങ്കിൽ ക്ലിയർ എന്നിവ തിരഞ്ഞെടുക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Once you have some text in the clipboard, you can pull down the Edit menu and select Paste to paste the clipboard text into the current file at the cursor position.","translation":"ക്ലിപ്ബോർഡിൽ കുറച്ച് ടെക്സ്റ്റ് ഉണ്ടെങ്കിൽ, എഡിറ്റ് മെനു തുറന്ന് പേസ്റ്റ് തിരഞ്ഞെടുത്ത് കേഴ്സർ സ്ഥാനത്ത് നിലവിലെ ഫയലിലേക്ക് ക്ലിപ്ബോർഡ് ടെക്സ്റ്റ് ഒട്ടിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This command is available only from the Edit menu.","translation":"ഈ കമാൻഡ് എഡിറ്റ് മെനുവിൽ മാത്രമേ ലഭ്യമാകൂ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can edit the text if you like, and your changes will be reflected in the text that you paste into your other file or files.","translation":"നിങ്ങൾക്ക് വേണമെങ്കിൽ ടെക്സ്റ്റ് എഡിറ്റ് ചെയ്യാം, കൂടാതെ നിങ്ങൾ മറ്റ് ഫയലുകളിലേക്ക് ഒട്ടിക്കുന്ന ടെക്സ്റ്റിൽ നിങ്ങളുടെ മാറ്റങ്ങൾ പ്രതിഫലിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The clipboard text, however, remains on the clipboard.","translation":"എങ്കിലും, ക്ലിപ്ബോർഡ് ടെക്സ്റ്റ് ക്ലിപ്ബോർഡിൽ തന്നെ നിലനിൽക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Searching for Text Much of the power of electronic text editing lies in its ability to search for a particular character pattern in a text file.","translation":"ഒരു ടെക്സ്റ്റ് ഫയലിൽ ഒരു പ്രത്യേക പ്രതീക പാറ്റേൺ തിരയാനുള്ള കഴിവിൽ ഇലക്ട്രോണിക് ടെക്സ്റ്റ് എഡിറ്റിംഗിന്റെ ശക്തി ഒളിഞ്ഞിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Furthermore, once found, it's a logical extension of the search concept to replace the found text string with a different text string.","translation":"കൂടാതെ, കണ്ടെത്തിയ ശേഷം, കണ്ടെത്തിയ ടെക്സ്റ്റ് സ്ട്രിംഗിനെ മറ്റൊരു ടെക്സ്റ്റ് സ്ട്രിംഗ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നത് തിരയൽ ആശയത്തിന്റെ യുക്തിപരമായ വിപുലീകരണമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"For example: Suppose you're looking for the register name \"AX.\"","translation":"ഉദാഹരണത്തിന്: നിങ്ങൾ \"AX.\" എന്ന രജിസ്റ്റർ നാമം തിരയുകയാണെന്ന് കരുതുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you don't check Whole words only, your search for \"AX\" will also find \"Axe\" because \"ax\" is inside \"axe.\"","translation":"നിങ്ങൾ മുഴുവൻ വാക്കുകൾ മാത്രം (Whole words only) തിരഞ്ഞെടുത്തില്ലെങ്കിൽ, \"AX\" എന്നതിനായുള്ള നിങ്ങളുടെ തിരയൽ \"Axe\" എന്നതും കണ്ടെത്തും, കാരണം \"ax\", \"axe\" എന്നതിനകത്താണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Once you have the Find dialog box filled in the way you want it, press the OK button.","translation":"നിങ്ങൾ ആഗ്രഹിക്കുന്ന രീതിയിൽ ഫൈൻഡ് ഡയലോഗ് ബോക്സ് (Find dialog box) പൂരിപ്പിച്ച ശേഷം, ശരി ബട്ടൺ അമർത്തുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The search will commence, and if the search is successful the cursor will move to the first character of the first instance of the found text string.","translation":"തിരയൽ ആരംഭിക്കും, തിരയൽ വിജയകരമാണെങ്കിൽ, കണ്ടെത്തിയ ടെക്സ്റ്റ് സ്ട്രിംഗിന്റെ ആദ്യ സംഭവത്തിന്റെ ആദ്യ അക്ഷരത്തിലേക്ക് കേഴ്സർ നീങ്ങും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"If you want to find not the first one but the third or fourth (or one further down that you know you can identify from its context), you need to search for additional instances of the text.","translation":"ഒന്നാമത്തേതല്ല, മൂന്നാമത്തേതോ നാലാമത്തേതോ (അല്ലെങ്കിൽ അതിന്റെ പശ്ചാത്തലത്തിൽ നിന്ന് തിരിച്ചറിയാൻ കഴിയുന്ന ഒന്ന്) കണ്ടെത്തണമെങ്കിൽ, നിങ്ങൾ ടെക്സ്റ്റിന്റെ കൂടുതൽ സംഭവങ്ങൾക്കായി തിരയേണ്ടതുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"NASM-IDE has special machinery to do exactly this: the Replace command.","translation":"കൃത്യമായി ഇത് ചെയ്യുന്നതിന് NASM-IDE-ക്ക് പ്രത്യേക സംവിധാനമുണ്ട്: റീപ്ലേസ് കമാൻഡ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You are editing entirely within memory.","translation":"നിങ്ങൾ പൂർണ്ണമായും മെമ്മറിയിലാണ് എഡിറ്റ് ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You must develop the discipline of saving your work every so often.","translation":"നിങ്ങളുടെ ജോലി ഇടയ്ക്കിടെ സംരക്ഷിക്കുന്ന ഒരു ശീലം നിങ്ങൾ വളർത്തണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding the way segments work will help you understand how the two x86 flat models work.","translation":"സെഗ്മെന്റുകൾ എങ്ങനെ പ്രവർത്തിക്കുമെന്നത് മനസ്സിലാക്കുന്നത് രണ്ട് x86 ഫ്ലാറ്റ് മോഡലുകൾ എങ്ങനെ പ്രവർത്തിക്കുമെന്നത് മനസ്സിലാക്കാൻ നിങ്ങളെ സഹായിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Programming involves two major components of the PC: the CPU and memory.","translation":"പ്രോഗ്രാമിംഗിൽ കമ്പ്യൂട്ടറിന്റെ രണ്ട് പ്രധാന ഘടകങ്ങൾ ഉൾപ്പെടുന്നു: CPU, മെമ്മറി എന്നിവയാണവ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Most modern x86 machines have a lot more memory than that—typically 32 MB or more.","translation":"ആധുനിക x86 മെഷീനുകളിൽ അതിലും കൂടുതൽ മെമ്മറി ഉണ്ട് - സാധാരണയായി 32 MB അല്ലെങ്കിൽ അതിൽ കൂടുതൽ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"However, most modern x86 machines run in protected mode, which can address up to 4 giga bytes of memory.","translation":"എങ്കിലും, ആധുനിക x86 മെഷീനുകൾ പ്രൊട്ടക്റ്റഡ് മോഡിലാണ് പ്രവർത്തിക്കുന്നത്, ഇത് 4 ഗിഗാബൈറ്റ് വരെ മെമ്മറിയെ അഭിസംബോധന ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"We return to protected mode in a big way toward the end of this book, in discussing Linux.","translation":"ഈ പുസ്തകത്തിന്റെ അവസാന ഭാഗത്ത്, ലിനക്സിനെക്കുറിച്ച് ചർച്ച ചെയ്യുമ്പോൾ, നമ്മൾ വീണ്ടും പ്രൊട്ടക്റ്റഡ് മോഡിലേക്ക് വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It doesn't come out even in our base 10 because computers insist on base 2.","translation":"കമ്പ്യൂട്ടറുകൾ ബേസ് 2 ഉപയോഗിക്കുന്നതുകൊണ്ട് ഇത് നമ്മുടെ ബേസ് 10-ൽ കൃത്യമായി വരില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The number 100000000000000000000B is so bulky that it's better to express it in the compatible (and much more compact) base 16, which we call hexadecimal.","translation":"100000000000000000000B എന്ന സംഖ്യ വളരെ വലുതായതുകൊണ്ട്, ഇത് അനുയോജ്യമായ (കൂടുതൽ ഒതുക്കമുള്ള) ബേസ് 16-ൽ പ്രകടിപ്പിക്കുന്നതാണ് നല്ലത്, ഇതിനെ നമ്മൾ ഹെക്സാഡെസിമൽ എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In a bank of memory containing 100000H bytes, what's the address of the very last byte in the memory bank?","translation":"100000H ബൈറ്റുകൾ അടങ്ങിയ ഒരു മെമ്മറി ബാങ്കിൽ, മെമ്മറി ബാങ്കിലെ അവസാനത്തെ ബൈറ്റിന്റെ വിലാസം എന്തായിരിക്കും?","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Computers always begin counting from 0.","translation":"കമ്പ്യൂട്ടറുകൾ എപ്പോഴും 0-യിൽ നിന്നാണ് എണ്ണാൻ തുടങ്ങുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The address of a byte in a memory bank is just the number of that byte starting from zero.","translation":"ഒരു മെമ്മറി ബാങ്കിലെ ഒരു ബൈറ്റിന്റെ വിലാസം, പൂജ്യത്തിൽ നിന്ന് തുടങ്ങുന്ന ആ ബൈറ്റിന്റെ സംഖ്യയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The addresses in a megabyte of memory, then, run from 00000H to 0FFFFFH.","translation":"ഒരു മെഗാബൈറ്റ് മെമ്മറിയിലെ വിലാസങ്ങൾ 00000H മുതൽ 0FFFFFH വരെയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"That's what a megabyte of memory is: some arrangement of memory chips within the computer, connected by an address bus of 20 lines.","translation":"ഒരു മെഗാബൈറ്റ് മെമ്മറി എന്നാൽ കമ്പ്യൂട്ടറിനുള്ളിലെ മെമ്മറി ചിപ്പുകളുടെ ക്രമീകരണമാണ്, ഇത് 20 ലൈനുകളുള്ള ഒരു വിലാസ ബസ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"When a Pentium CPU places itself into real mode segmented model, it very nearly becomes an 8086.","translation":"ഒരു പെൻ്റിയം CPU റിയൽ മോഡ് സെഗ്മെന്റഡ് മോഡിലേക്ക് വരുമ്പോൾ, അത് ഏകദേശം 8086-ന് തുല്യമാകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Think of it as training wheels to get you up to speed in assembly language.","translation":"അസംബ്ലി ഭാഷയിൽ വേഗത കൈവരിക്കാൻ ഇത് ഒരു പരിശീലനമായി കണക്കാക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When you launch an MS-DOS window or \"DOS box\" under Windows 9x or NT, you're creating what amounts to a little real mode island inside the Windows protected mode memory system.","translation":"വിൻഡോസ് 9x അല്ലെങ്കിൽ എൻ്റിന് കീഴിൽ ഒരു MS-DOS വിൻഡോ അല്ലെങ്കിൽ ","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In real mode segmented model, an x86 CPU can \"see\" a full megabyte of memory.","translation":"റിയൽ മോഡ് സെഗ്മെന്റഡ് മോഡിൽ, ഒരു x86 CPU-ന് ഒരു മെഗാബൈറ്റ് മെമ്മറി കാണാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU can slide that piece of cardboard up and down the full length of its memory system.","translation":"CPU-വിന് ആ കാർഡ്ബോർഡ് കഷണം മുകളിലേക്കും താഴേക്കും നീക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The chunks are called segments, and it's time to take a closer look at what they are and how they're used.","translation":"കഷണങ്ങളെ സെഗ്മെന്റുകൾ എന്ന് വിളിക്കുന്നു, അവ എന്താണെന്നും എങ്ങനെ ഉപയോഗിക്കുന്നു എന്നും സൂക്ഷ്മമായി പരിശോധിക്കേണ്ട സമയമാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"More formally, a segment is a region of memory that begins on a paragraph boundary and extends for some number of bytes.","translation":"കൂടുതൽ ഔദ്യോഗികമായി പറഞ്ഞാൽ, ഒരു സെഗ്മെന്റ് എന്നത് ഒരു ഖണ്ഡികാ അതിർത്തിയിൽ ആരംഭിച്ച് കുറച്ച് ബൈറ്റുകൾ വരെ നീളുന്ന മെമ്മറിയുടെ ഭാഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"An assembly language program may make use of only four or five segments, but each of those segments may begin at any of the 65,536 paragraph boundaries existing in the megabyte of memory available in the real mode segmented model.","translation":"അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിന് നാലോ അഞ്ചോ സെഗ്മെന്റുകൾ മാത്രമേ ഉപയോഗിക്കാൻ കഴിയൂ, എന്നാൽ റിയൽ മോഡ് സെഗ്മെന്റഡ് മോഡിൽ ലഭ്യമായ മെമ്മറിയുടെ മെഗാബൈറ്റിൽ നിലവിലുള്ള 65,536 ഖണ്ഡികാ അതിർത്തികളിൽ ഏതെങ്കിലും ഒന്നിൽ ഓരോ സെഗ്മെന്റും ആരംഭിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The general-purpose registers are memory locations existing inside the CPU chip itself.","translation":"പൊതു ആവശ്യങ്ങൾക്കായുള്ള രജിസ്റ്ററുകൾ CPU ചിപ്പിനുള്ളിൽ തന്നെയുള്ള മെമ്മറി സ്ഥാനങ്ങളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Also, like the segment registers, they all have names rather than numeric addresses.","translation":"സെഗ്മെൻ്റ് രജിസ്റ്ററുകളെപ്പോലെ, അവയ്ക്കെല്ലാം സംഖ്യാ വിലാസങ്ങളേക്കാൾ പേരുകളാണ് നൽകിയിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The general-purpose registers really are generalists in that all of them share a large suite of capabilities.","translation":"പൊതു ആവശ്യത്തിനുള്ള രജിസ്റ്ററുകൾ, അവയുടെ എല്ലാ കഴിവും പങ്കുവെക്കുന്നവയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"However, some of the general-purpose registers also have what I call a hidden agenda: a task or set of tasks that only it can perform.","translation":"എങ്കിലും, ചില പൊതു ആവശ്യത്തിനുള്ള രജിസ്റ്ററുകൾക്ക് എൻ്റെ ഭാഷയിൽ പറഞ്ഞാൽ ഒരു രഹസ്യ അജണ്ടയുണ്ട്: അതിന് മാത്രം ചെയ്യാൻ കഴിയുന്ന ഒരു ടാസ്ക്കോ അല്ലെങ്കിൽ ടാസ്ക്കുകളുടെ കൂട്ടമോ.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"I explain all these hidden agendas as I go—keeping in mind that some of the hidden agendas are actually limitations of the older 16-bit machines.","translation":"പഴയ 16-ബിറ്റ് മെഷീനുകളുടെ പരിമിതികളാണ് ചില രഹസ്യ അജണ്ടകൾ എന്ന് ഓർമ്മിച്ചുകൊണ്ട്, ഈ മറഞ്ഞിരിക്കുന്ന അജണ്ടകളെല്ലാം ഞാൻ വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The newer general-purpose registers are much more..., er,...general.","translation":"പുതിയ പൊതു ആവശ്യത്തിനുള്ള രജിസ്റ്ററുകൾ കൂടുതൽ പൊതുവായവയാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The general-purpose registers fall into three general classes: the 16-bit general-purpose registers, the 32-bit extended general-purpose registers, and the 8-bit register halves.","translation":"പൊതു ആവശ്യത്തിനുള്ള രജിസ്റ്ററുകൾ പ്രധാനമായും മൂന്ന് തരത്തിലുണ്ട്: 16-ബിറ്റ് ജനറൽ പർപ്പസ് രജിസ്റ്ററുകൾ, 32-ബിറ്റ് എക്സ്റ്റൻഡഡ് ജനറൽ പർപ്പസ് രജിസ്റ്ററുകൾ, 8-ബിറ്റ് രജിസ്റ്റർ ഭാഗങ്ങൾ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"These three classes do not represent three entirely distinct sets of registers at all.","translation":"ഈ മൂന്ന് ക്ലാസുകളും രജിസ്റ്ററുകളുടെ പൂർണ്ണമായും വ്യത്യസ്തമായ സെറ്റുകളല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The 16- bit and 8-bit registers are actually names of regions inside the 32-bit registers.","translation":"16-ബിറ്റ്, 8-ബിറ്റ് രജിസ്റ്ററുകൾ യഥാർത്ഥത്തിൽ 32-ബിറ്റ് രജിസ്റ്ററുകൾക്കുള്ളിലെ ഭാഗങ്ങളുടെ പേരുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Register growth in the x86 CPU family has come about by extending registers existing in older CPUs.","translation":"x86 CPU ഫാമിലിയിലെ രജിസ്റ്ററുകളുടെ വളർച്ച പഴയ CPU-കളിൽ നിലവിലുള്ള രജിസ്റ്ററുകൾ വികസിപ്പിച്ചതിലൂടെയാണ് സംഭവിച്ചത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Adding a room to your house doesn't make it two houses—just one bigger house.","translation":"നിങ്ങളുടെ വീട്ടിൽ ഒരു മുറി കൂട്ടിച്ചേർക്കുന്നത് രണ്ട് വീടുകളാക്കുന്നില്ല, മറിച്ച് ഒരു വലിയ വീടാക്കുന്നു.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"And so it has been with the x86 registers.","translation":"അതുപോലെയാണ് x86 രജിസ്റ്ററുകളുടെ കാര്യവും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"There are eight 16-bit general-purpose registers: AX, BX, CX, DX, BP, SI, DI, and SP.","translation":"AX, BX, CX, DX, BP, SI, DI, SP എന്നിവയാണ് എട്ട് 16-ബിറ്റ് പൊതു ആവശ്യത്തിനുള്ള രജിസ്റ്ററുകൾ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"(SP is a little less general than the others, but we'll get to that.)","translation":"(SP അത്ര പൊതുവായ ഒന്നല്ല, പക്ഷെ നമുക്കതിലേക്ക് വരാം.)","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"These all existed in the 8086, 8088, and 80286 CPUs.","translation":"ഇവയെല്ലാം 8086, 8088, 80286 CPU-കളിൽ നിലനിന്നിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"They are all 16 bits in size, and you can place any value in them that may be expressed in 16 bits or fewer.","translation":"അവയെല്ലാം 16 ബിറ്റുകളാണ്, കൂടാതെ 16 ബിറ്റോ അതിൽ കുറവോ ഉപയോഗിച്ച് പ്രകടിപ്പിക്കാൻ കഴിയുന്ന ഏത് മൂല്യവും നിങ്ങൾക്ക് അതിൽ സ്ഥാപിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When Intel expanded the x86 architecture to 32 bits in 1986, it doubled the size of all eight registers and gave them new names by prefixing an E in front of each register name, resulting in EAX, EBX, ECX, EDX, EBP, ESI, EDI, and ESP.","translation":"1986-ൽ ഇന്റൽ x86 ആർക്കിടെക്ചർ 32 ബിറ്റിലേക്ക് വികസിപ്പിച്ചപ്പോൾ, എട്ട് രജിസ്റ്ററുകളുടെയും വലുപ്പം ഇരട്ടിയാക്കുകയും ഓരോ രജിസ്റ്റർ നാമത്തിനും E ചേർത്ത് EAX, EBX, ECX, EDX, EBP, ESI, EDI, ESP എന്നിങ്ങനെ പുതിയ പേരുകൾ നൽകുകയും ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"So...were these just bigger registers, or new registers? Both.","translation":"അപ്പോൾ...ഇവ വലിയ രജിസ്റ്ററുകളായിരുന്നോ അതോ പുതിയ രജിസ്റ്ററുകളായിരുന്നോ? രണ്ടും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"As with a lot of things in assembly language, this becomes a lot clearer by drawing a diagram.","translation":"അസംബ്ലി ഭാഷയിലെ പല കാര്യങ്ങളിലും എന്നപോലെ, ഒരു ഡയഗ്രം വരയ്ക്കുന്നതിലൂടെ ഇത് കൂടുതൽ വ്യക്തമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Each of the four registers shown in Figure 6.6 is fully 32 bits in size.","translation":"ചിത്രം 6.6-ൽ കാണിച്ചിരിക്കുന്ന നാല് രജിസ്റ്ററുകളും പൂർണ്ണമായും 32 ബിറ്റുകളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The MOV instruction is the most common activity in assembly language work.","translation":"അസംബ്ലി ഭാഷയിൽ ഏറ്റവും സാധാരണയായി ഉപയോഗിക്കുന്ന ഒരു പ്രവർത്തനമാണ് MOV നിർദ്ദേശം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding how the CPU and its instructions address memory is more difficult but probably more important than understanding the instructions themselves.","translation":"CPU-ഉം അതിൻ്റെ നിർദ്ദേശങ്ങളും മെമ്മറിയെ എങ്ങനെ അഭിസംബോധന ചെയ്യുന്നു എന്ന് മനസ്സിലാക്കുന്നത് കൂടുതൽ ബുദ്ധിമുട്ടുള്ള കാര്യമാണ്, എന്നാൽ നിർദ്ദേശങ്ങൾ മനസ്സിലാക്കുന്നതിനേക്കാൾ പ്രാധാന്യമുള്ള ഒന്നാണ് ഇത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Assembling and Executing Machine Instructions with DEBUG is a useful method.","translation":"DEBUG ഉപയോഗിച്ച് മെഷീൻ നിർദ്ദേശങ്ങൾ അസംബിൾ ചെയ്യുകയും എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നത് വളരെ പ്രയോജനകരമായ ഒരു രീതിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The MOV instruction can move a byte, word (16 bits), or double word (32 bits) of data.","translation":"MOV നിർദ്ദേശത്തിന് ഒരു ബൈറ്റ്, വേർഡ് (16 ബിറ്റുകൾ), അല്ലെങ്കിൽ ഡബിൾ വേർഡ് (32 ബിറ്റുകൾ) ഡാറ്റ നീക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Once copied to the destination, the data does not vanish from the source.","translation":"ലക്ഷ്യസ്ഥാനത്തേക്ക് പകർത്തിയ ശേഷം, ഡാറ്റ ഉറവിടത്തിൽ നിന്ന് അപ്രത്യക്ഷമാകില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Bring up DEBUG and use the R command to display the current state of the registers.","translation":"DEBUG തുറന്ന്, രജിസ്റ്ററുകളുടെ ഇപ്പോഴത്തെ അവസ്ഥ കാണുന്നതിന് R കമാൻഡ് ഉപയോഗിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Memory is never really empty.","translation":"മെമ്മറി ഒരിക്കലും ശൂന്യമായിരിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Machine instructions are just numbers, after all.","translation":"മെഷീൻ നിർദ്ദേശങ്ങൾ, എല്ലാത്തിനുമുപരി, സംഖ്യകൾ മാത്രമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Type the A command (for Assemble) and press Enter.","translation":"A കമാൻഡ് ടൈപ്പ് ചെയ്യുക (അസംബിളിനായി) തുടർന്ന് Enter അമർത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The registers haven't changed—but now the third line shows that the JO instruction is gone.","translation":"രജിസ്റ്ററുകൾ മാറിയിട്ടില്ല - എന്നാൽ ഇപ്പോൾ മൂന്നാമത്തെ വരിയിൽ JO നിർദ്ദേശം പോയെന്ന് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Trace executes the single instruction at CS:IP.","translation":"Trace, CS:IP-യിലെ ഒരൊറ്റ നിർദ്ദേശം എക്സിക്യൂട്ട് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The Trace command will execute the machine instruction at CS:IP.","translation":"Trace കമാൻഡ് CS:IP-യിലെ മെഷീൻ നിർദ്ദേശം എക്സിക്യൂട്ട് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"DEBUG says AX is now equal to 0001.","translation":"AX ഇപ്പോൾ 0001-ന് തുല്യമാണെന്ന് DEBUG പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"MOV copies data from a source to a destination.","translation":"MOV ഒരു ഉറവിടത്തിൽ നിന്ന് ഡാറ്റ ഒരു ലക്ഷ്യസ്ഥാനത്തേക്ക് പകർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The first operand belonging to a machine instruction is the destination operand.","translation":"ഒരു മെഷീൻ നിർദ്ദേശത്തിലെ ആദ്യത്തെ ഓപ്പറാൻഡ് ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Immediate data is built right into the machine instruction.","translation":"ഉടനടി ലഭിക്കുന്ന ഡാറ്റ മെഷീൻ നിർദ്ദേശത്തിൽ തന്നെ ഉൾപ്പെടുത്തിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Fetching anything from memory takes more time than fetching anything from a register.","translation":"മെമ്മറിയിൽ നിന്ന് എന്തെങ്കിലും എടുക്കാൻ, ഒരു രജിസ്റ്ററിൽ നിന്ന് എടുക്കുന്നതിനേക്കാൾ കൂടുതൽ സമയം എടുക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Register addressing is done by simply naming the register we want to work with.","translation":"രജിസ്റ്റർ വിലാസം നൽകുന്നത്, നമ്മൾ പ്രവർത്തിക്കാൻ ആഗ്രഹിക്കുന്ന രജിസ്റ്റർ വ്യക്തമാക്കുന്നതിലൂടെയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler keeps track of certain things that don't make sense.","translation":"അസംബ്ലർ, അർത്ഥമില്ലാത്ത ചില കാര്യങ്ങൾ ട്രാക്ക് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In real mode, only BP, BX, SI, and DI may hold an offset for memory data.","translation":"റിയൽ മോഡിൽ, BP, BX, SI, കൂടാതെ DI എന്നിവയ്ക്ക് മാത്രമേ മെമ്മറി ഡാറ്റയ്ക്കായി ഒരു ഓഫ്സെറ്റ് നിലനിർത്താൻ കഴിയൂ.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Memory addressing and registers are key in this business.","translation":"ഈ കാര്യത്തിൽ മെമ്മറി വിലാസവും രജിസ്റ്ററുകളും പ്രധാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you know them, the instructions will be a snap.","translation":"നിങ്ങൾക്ക് അവ അറിയാമെങ്കിൽ, നിർദ്ദേശങ്ങൾ വളരെ എളുപ്പമായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"What difficulty exists in programming for protected mode flat model lies in understanding the operating system.","translation":"പ്രൊട്ടക്റ്റഡ് മോഡ് ഫ്ലാറ്റ് മോഡലിനായി പ്രോഗ്രാം ചെയ്യുന്നതിലെ ബുദ്ധിമുട്ട്, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം മനസ്സിലാക്കുന്നതിലാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This book is only the beginning-there's a long road out there to be walked, and you're barely off the curb.","translation":"ഈ പുസ്തകം ഒരു തുടക്കം മാത്രമാണ് - ഒരുപാട് ദൂരം ഇനിയും നടക്കാനുണ്ട്, നിങ്ങൾ ഇപ്പോഴും നടപ്പാതയിൽ നിന്ന് ഇറങ്ങിയിട്ടേയുള്ളൂ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"While you're developing and debugging your programs, a lot of what you'll be looking at is the contents of your registers.","translation":"നിങ്ങൾ പ്രോഗ്രാമുകൾ വികസിപ്പിക്കുകയും ഡീബഗ് ചെയ്യുകയും ചെയ്യുമ്പോൾ, നിങ്ങൾ പ്രധാനമായും ശ്രദ്ധിക്കുന്നത് നിങ്ങളുടെ രജിസ്റ്ററുകളുടെ ഉള്ളടക്കമായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The DOS DEBUG utility provides a handy window into the CPU's hidden world of registers.","translation":"DOS DEBUG യൂട്ടിലിറ്റി, CPU-വിൻ്റെ രജിസ്റ്ററുകളുടെ രഹസ്യ ലോകത്തേക്ക് ഒരു വിൻഡോ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"For now, just consider DEBUG a magic box.","translation":"ഇപ്പോൾ, DEBUG ഒരു മാന്ത്രിക പെട്ടിയാണെന്ന് കരുതുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Simply run DEBUG, and at the dash prompt type the single-letter command R.","translation":"DEBUG പ്രവർത്തിപ്പിക്കുക, തുടർന്ന് ഡാഷ് പ്രൊംപ്റ്റിൽ R എന്ന ഒരൊറ്റ അക്ഷര കമാൻഡ് ടൈപ്പ് ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"What will not vary is the fact that every CPU register has its place in the display, along with its current value shown to the right of an equals sign.","translation":"എല്ലാ CPU രജിസ്റ്ററുകൾക്കും ഡിസ്പ്ലേയിൽ അതിൻ്റേതായ സ്ഥാനമുണ്ട്, കൂടാതെ സമചിഹ്നത്തിന് വലതുവശത്ത് അതിൻ്റെ നിലവിലെ മൂല്യവും കാണിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Changing a register is done very simply, again using DEBUG's R command.","translation":"ഒരു രജിസ്റ്റർ മാറ്റുന്നത് വളരെ ലളിതമായി ചെയ്യാവുന്നതാണ്, വീണ്ടും DEBUG-ൻ്റെ R കമാൻഡ് ഉപയോഗിച്ച്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"To change the value of AX, type R AX and press Enter.","translation":"AX-ൻ്റെ മൂല്യം മാറ്റാൻ, R AX എന്ന് ടൈപ്പ് ചെയ്ത് Enter അമർത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Take a few minutes to practice entering new values for the general-purpose registers, then display the registers as a group to verify that the changes were made.","translation":"ജനറൽ പർപ്പസ് രജിസ്റ്ററുകൾക്കായി പുതിയ മൂല്യങ്ങൾ നൽകി പരിശീലിക്കാൻ കുറച്ച് മിനിറ്റ് എടുക്കുക, തുടർന്ന് മാറ്റങ്ങൾ വരുത്തിയെന്ന് ഉറപ്പാക്കാൻ രജിസ്റ്ററുകൾ ഒരു ഗ്രൂപ്പായി പ്രദർശിപ്പിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One good way to help your knowledge of memory addressing sink in is to use DEBUG to take a look at some interesting places in the PC's memory space.","translation":"മെമ്മറി വിലാസത്തെക്കുറിച്ചുള്ള നിങ്ങളുടെ അറിവ് വർദ്ധിപ്പിക്കാനുള്ള ഒരു നല്ല മാർഗ്ഗം, PC-യുടെ മെമ്മറി ഇടത്തിലെ ചില രസകരമായ സ്ഥലങ്ങൾ കാണുന്നതിന് DEBUG ഉപയോഗിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"One easy thing to do is look at the PC's video display adapter's text screen video refresh buffer.","translation":"ചെയ്യാൻ എളുപ്പമുള്ള ഒന്ന്, PC-യുടെ വീഡിയോ ഡിസ്പ്ലേ അഡാപ്റ്ററിൻ്റെ ടെക്സ്റ്റ് സ്ക്രീൻ വീഡിയോ റിഫ്രഷ് ബഫർ പരിശോധിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The text mode display buffer is the screen that appears when you're running DOS or else working in a DOS window (or \"DOS box\") from within MS Windows.","translation":"ടെക്സ്റ്റ് മോഡ് ഡിസ്പ്ലേ ബഫർ എന്നത് നിങ്ങൾ DOS പ്രവർത്തിപ്പിക്കുമ്പോഴോ അല്ലെങ്കിൽ MS വിൻഡോസിനുള്ളിൽ ഒരു DOS വിൻഡോയിൽ (","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"It consists not of icons or graphical images or figures but simple textual characters, arranged in a matrix typically 25 high and 80 wide.","translation":"ഇതിൽ ഐക്കണുകളോ, ഗ്രാഫിക്കൽ ചിത്രങ്ങളോ, രൂപങ്ങളോ അടങ്ങിയിട്ടില്ല, മറിച്ച് ലളിതമായ ടെക്സ്റ്റ് അക്ഷരങ്ങൾ, സാധാരണയായി 25 ഉയരവും 80 വീതിയും ഉള്ള ഒരു മാട്രിക്സിൽ ക്രമീകരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"As with any memory location anywhere within the PC, the video refresh buffer has a segment address.","translation":"PC-ക്കുള്ളിലെ ഏതൊരു മെമ്മറി ലൊക്കേഷനെയും പോലെ, വീഡിയോ റിഫ്രഷ് ബഫറിനും ഒരു സെഗ്മെൻ്റ് വിലാസമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If your PC has a color screen, the segment address of the video refresh buffer is 0B800H.","translation":"നിങ്ങളുടെ PC-ക്ക് കളർ സ്ക്രീൻ ഉണ്ടെങ്കിൽ, വീഡിയോ റിഫ്രഷ് ബഫറിൻ്റെ സെഗ്മെൻ്റ് വിലാസം 0B800H ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The very first character/attribute pair in the video refresh buffer corresponds to the character you see in the upper-left-hand corner of the text screen.","translation":"വീഡിയോ റിഫ്രഷ് ബഫറിലെ ആദ്യത്തെ പ്രതീകം/ആട്രിബ്യൂട്ട് ജോഡി, ടെക്സ്റ്റ് സ്ക്രീനിൻ്റെ മുകളിൽ ഇടത് കോണിൽ നിങ്ങൾ കാണുന്ന പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You can inspect the memory within the video refresh buffer directly, through DEBUG.","translation":"DEBUG വഴി, വീഡിയോ റിഫ്രഷ് ബഫറിനുള്ളിലെ മെമ്മറി നിങ്ങൾക്ക് നേരിട്ട് പരിശോധിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can move an immediate value to memory.","translation":"നിങ്ങൾക്ക് ഒരു തൽക്ഷണ മൂല്യം മെമ്മറിയിലേക്ക് നീക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Specifying a memory address as one of an instruction's operands is a little complicated.","translation":"ഒരു നിർദ്ദേശത്തിന്റെ ഓപ്പറാൻഡുകളിലൊന്നായി ഒരു മെമ്മറി വിലാസം വ്യക്തമാക്കുന്നത് അൽപ്പം സങ്കീർണ്ണമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"To move the word at address DS:BX into register AX, we would use the following instruction: MOV AX,[BX]","translation":"DS:BX എന്ന വിലാസത്തിലുള്ള വാക്ക് AX എന്ന രജിസ്റ്ററിലേക്ക് നീക്കാൻ, നമ്മൾ താഴെ പറയുന്ന നിർദ്ദേശം ഉപയോഗിക്കും: MOV AX,[BX]","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Similarly, to move a value residing in register DX into the word at address DS:DI, you would use this instruction: MOV [DI],DX","translation":"അതുപോലെ, DX എന്ന രജിസ്റ്ററിലുള്ള ഒരു മൂല്യം DS:DI എന്ന വിലാസത്തിലുള്ള വാക്കിലേക്ക് നീക്കാൻ, നിങ്ങൾ ഈ നിർദ്ദേശം ഉപയോഗിക്കും: MOV [DI],DX","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One of these assumptions is that in working with memory data, the MOV instruction uses the segment address stored in segment register DS unless you explicitly tell it otherwise.","translation":"ഈ അനുമാനങ്ങളിലൊന്ന്, മെമ്മറി ഡാറ്റയിൽ പ്രവർത്തിക്കുമ്പോൾ, MOV നിർദ്ദേശം സെഗ്മെന്റ് രജിസ്റ്റർ DS-ൽ സംഭരിച്ചിരിക്കുന്ന സെഗ്മെന്റ് വിലാസം ഉപയോഗിക്കുന്നു, നിങ്ങൾ വ്യക്തമായി മറ്റുവിധത്തിൽ പറയാത്ത പക്ഷം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"However, had you specified the offset as residing in register SP instead of BX or DI, the MOV instruction would have assumed the use of segment register SS instead.","translation":"എങ്കിലും, BX അല്ലെങ്കിൽ DI എന്നിവയ്ക്ക് പകരമായി SP എന്ന രജിസ്റ്ററിലാണ് ഓഫ്സെറ്റ് സ്ഥിതി ചെയ്യുന്നത് എന്ന് നിങ്ങൾ പറഞ്ഞിരുന്നെങ്കിൽ, MOV നിർദ്ദേശം സെഗ്മെന്റ് രജിസ്റ്റർ SS ഉപയോഗിക്കുമെന്ന് അനുമാനിക്കുമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The instruction set includes what are called segment override prefixes.","translation":"നിർദ്ദേശ സെറ്റിൽ സെഗ്മെന്റ് ഓവർറൈഡ് പ്രിഫിക്സുകൾ എന്ന് വിളിക്കപ്പെടുന്നവ ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In use, the segment override prefix is placed immediately in front of the memory data reference whose segment register assumption is to be overridden.","translation":"ഉപയോഗിക്കുമ്പോൾ, സെഗ്മെന്റ് ഓവർറൈഡ് പ്രിഫിക്സ്, സെഗ്മെന്റ് രജിസ്റ്റർ അനുമാനം ഓവർറൈഡ് ചെയ്യേണ്ട മെമ്മറി ഡാറ്റ റഫറൻസിന് തൊട്ടുമുൻപായി സ്ഥാപിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"For example, to force a MOV instruction to copy a value from the AX register into a location at some offset (contained in SI) into the code segment, you would use this instruction: MOV [CS:SI],AX","translation":"ഉദാഹരണത്തിന്, AX രജിസ്റ്ററിൽ നിന്നുള്ള ഒരു മൂല്യം കോഡ് സെഗ്മെന്റിലെ ചില ഓഫ്സെറ്റിലുള്ള (SI-ൽ അടങ്ങിയിരിക്കുന്നത്) ഒരു സ്ഥാനത്തേക്ക് പകർത്താൻ ഒരു MOV നിർദ്ദേശത്തെ നിർബന്ധിക്കാൻ, നിങ്ങൾ ഈ നിർദ്ദേശം ഉപയോഗിക്കും: MOV [CS:SI],AX","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Every reference to memory data includes either an assumed segment register or else a segment override prefix to specify a segment register other than the assumed segment register.","translation":"മെമ്മറി ഡാറ്റയിലേക്കുള്ള എല്ലാ റഫറൻസുകളിലും ഒന്നുകിൽ ഒരു അനുമാന സെഗ്മെന്റ് രജിസ്റ്റർ ഉൾപ്പെടുന്നു, അല്ലെങ്കിൽ അനുമാനിച്ച സെഗ്മെന്റ് രജിസ്റ്ററിന് പുറമെ മറ്റൊരു സെഗ്മെന്റ് രജിസ്റ്റർ വ്യക്തമാക്കുന്നതിന് ഒരു സെഗ്മെന്റ് ഓവർറൈഡ് പ്രിഫിക്സ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"At the machine-code level, a segment override prefix is a single binary byte.","translation":"മെഷീൻ കോഡ് തലത്തിൽ, ഒരു സെഗ്മെന്റ് ഓവർറൈഡ് പ്രിഫിക്സ് ഒരു ബൈനറി ബൈറ്റാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In the flat models you do not use segment overrides.","translation":"ഫ്ലാറ്റ് മോഡലുകളിൽ നിങ്ങൾ സെഗ്മെന്റ് ഓവർറൈഡുകൾ ഉപയോഗിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Real mode memory data consists of a single byte or word in memory, addressed by way of a segment value and an offset value.","translation":"റിയൽ മോഡ് മെമ്മറി ഡാറ്റയിൽ ഒരു സെഗ്മെന്റ് മൂല്യത്തിലൂടെയും ഒരു ഓഫ്സെറ്റ് മൂല്യത്തിലൂടെയും അഭിസംബോധന ചെയ്യപ്പെടുന്ന മെമ്മറിയിലെ ഒരു ബൈറ്റോ വാക്കോ അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The register containing the offset address is enclosed in square brackets to indicate that the contents of memory, rather than the contents of the register, are being addressed.","translation":"ഓഫ്സെറ്റ് വിലാസം അടങ്ങിയിരിക്കുന്ന രജിസ്റ്റർ, രജിസ്റ്ററിലെ ഉള്ളടക്കങ്ങൾക്കുവേണ്ടി, മെമ്മറിയുടെ ഉള്ളടക്കങ്ങൾ അഭിസംബോധന ചെയ്യപ്പെടുന്നു എന്ന് സൂചിപ്പിക്കാൻ സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The segment register used to address memory data is usually assumed according to a complex set of rules.","translation":"മെമ്മറി ഡാറ്റയെ അഭിസംബോധന ചെയ്യാൻ ഉപയോഗിക്കുന്ന സെഗ്മെന്റ് രജിസ്റ്റർ സാധാരണയായി സങ്കീർണ്ണമായ നിയമങ്ങൾ അനുസരിച്ച് അനുമാനിക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU sends out the values in ES and BX to the memory system side by side.","translation":"ES, BX എന്നിവയിലെ മൂല്യങ്ങൾ CPU മെമ്മറി സിസ്റ്റത്തിലേക്ക് ഒരുമിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The MOV instruction can move nearly any register to any other register.","translation":"MOV നിർദ്ദേശത്തിന് ഏതാണ്ട് ഏതെങ്കിലും രജിസ്റ്ററിനെ മറ്റേതെങ്കിലും രജിസ്റ്ററിലേക്ക് നീക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"MOV cannot move memory data to memory data.","translation":"MOV-ന് മെമ്മറി ഡാറ്റയെ മെമ്മറി ഡാറ്റയിലേക്ക് നീക്കാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"MOV cannot move one segment register into another.","translation":"MOV-ന് ഒരു സെഗ്മെന്റ് രജിസ്റ്ററിനെ മറ്റൊന്നിലേക്ക് നീക്കാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In Microsoft's MASM, memory data that includes a segment override must be coded like this: MOV AX,ES:[BX]","translation":"Microsoft-ൻ്റെ MASM-ൽ, സെഗ്മെൻ്റ് ഓവർറൈഡ് ഉൾപ്പെടുന്ന മെമ്മറി ഡാറ്റ ഈ രീതിയിൽ കോഡ് ചെയ്യണം: MOV AX,ES:[BX]","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Each instruction uses some number of those cycles to do its work, and the number varies all over the map.","translation":"ഓരോ നിർദ്ദേശവും അതിന്റെ ജോലി ചെയ്യാൻ ആ സൈക്കിളുകളിൽ കുറച്ച് എണ്ണം ഉപയോഗിക്കുന്നു, കൂടാതെ എണ്ണം എല്ലാ സ്ഥലത്തും വ്യത്യാസപ്പെട്ടിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Knowing the cycle requirements for individual instructions is rarely sufficient to allow even an expert assembly language programmer to calculate how much time a given series of instructions will take.","translation":"പ്രത്യേക നിർദ്ദേശങ്ങൾക്കുള്ള സൈക്കിൾ ആവശ്യകതകൾ അറിയുന്നത്, ഒരു കൂട്ടം നിർദ്ദേശങ്ങൾ എത്ര സമയം എടുക്കുമെന്ന് കണക്കാക്കാൻ ഒരു വിദഗ്ദ്ധ അസംബ്ലി ഭാഷാ പ്രോഗ്രാമറെപ്പോലും അനുവദിക്കാൻ മതിയായതല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Flags is a veritable junk drawer of disjointed little bits of information.","translation":"ഫ്ലാഗുകൾ വിവരങ്ങളുടെ ചിതറിക്കിടക്കുന്ന ചെറിയ ഭാഗങ്ങളുടെ ഒരു യഥാർത്ഥ ജങ്ക് ഡ്രോയറാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Each of the Flags register's nine flags has a two-letter symbol by which most programmers know them.","translation":"ഫ്ലാഗ്സ് രജിസ്റ്ററിലെ ഒമ്പത് ഫ്ലാഗുകളിൽ ഓരോന്നിനും രണ്ട് അക്ഷര ചിഹ്നമുണ്ട്, അത് most പ്രോഗ്രാമർമാർക്കും അറിയാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The Overflow flag is set when the result of an operation becomes too large to fit in the operand it originally occupied.","translation":"ഒരു ഓപ്പറേഷന്റെ ഫലം, അത് ആദ്യം ഉൾക്കൊണ്ടിരുന്ന ഓപ്പറാൻഡിൽ ഉൾക്കൊള്ളാൻ കഴിയാത്തത്ര വലുതാകുമ്പോൾ, ഓവർഫ്ലോ ഫ്ലാഗ് സജ്ജമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It dictates the direction that activity moves during the execution of string instructions.","translation":"സ്ട്രിംഗ് നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുമ്പോൾ പ്രവർത്തനങ്ങൾ നീങ്ങുന്ന ദിശ ഇത് നിർണ്ണയിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When IF is set, interrupts are enabled and may occur when requested.","translation":"IF സജ്ജീകരിക്കുമ്പോൾ, തടസ്സങ്ങൾ പ്രവർത്തനക്ഷമമാക്കുകയും ആവശ്യപ്പെടുമ്പോൾ സംഭവിക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The Zero flag becomes set when the results of an operation become zero.","translation":"ഒരു ഓപ്പറേഷന്റെ ഫലം പൂജ്യമാകുമ്പോൾ, സീറോ ഫ്ലാഗ് സജ്ജമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The Carry flag is by far the most useful flag in the Flags register, and the one you will have to pay attention to most.","translation":"ഫ്ലാഗ്സ് രജിസ്റ്ററിലെ ഏറ്റവും ഉപയോഗപ്രദമായ ഫ്ലാഗാണ് കാരി ഫ്ലാഗ്, നിങ്ങൾ ഏറ്റവും കൂടുതൽ ശ്രദ്ധിക്കേണ്ട ഒന്ന്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Flag etiquette for individual flags varies widely from instruction to instruction.","translation":"പ്രത്യേക ഫ്ലാഗ്സിനായുള്ള ഫ്ലാഗ് മര്യാദകൾ നിർദ്ദേശത്തിനനുസരിച്ച് വളരെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Adding one to something or subtracting one from something are actions that happen a lot in computer programming.","translation":"ഒന്നിലേക്ക് ഒരെണ്ണം കൂട്ടിച്ചേർക്കുന്നതും അല്ലെങ്കിൽ ഒന്നിൽ നിന്ന് ഒരെണ്ണം കുറയ്ക്കുന്നതും കമ്പ്യൂട്ടർ പ്രോഗ്രാമിംഗിൽ ധാരാളമായി സംഭവിക്കുന്ന കാര്യങ്ങളാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Decrementing BX predictably turns the value 2DH into value 2CH.","translation":"BX കുറയ്ക്കുന്നത് പ്രവചനാതീതമായി മൂല്യം 2DH നെ 2CH ആക്കി മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Incrementing 0FFFFH, on the other hand, rolls over the register to 0.","translation":"മറുവശത്ത്, 0FFFFH വർദ്ധിപ്പിക്കുന്നത് രജിസ്റ്ററിനെ 0 ആയി മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The Zero flag works that way: When the result of an operation becomes zero, ZF is almost always set.","translation":"സീറോ ഫ്ലാഗ് ആ രീതിയിൽ പ്രവർത്തിക്കുന്നു: ഒരു ഓപ്പറേഷന്റെ ഫലം പൂജ്യമാകുമ്പോൾ, ZF മിക്കവാറും എപ്പോഴും സജ്ജമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DEBUG allows you to see the flags as they change, just as it lets you dump memory and examine the values in the general-purpose and segment registers.","translation":"മെമ്മറി ഡംപ് ചെയ്യാനും പൊതു ആവശ്യത്തിനുള്ളതും സെഗ്മെന്റ് രജിസ്റ്ററുകളിലെതുമായ മൂല്യങ്ങൾ പരിശോധിക്കാനും അനുവദിക്കുന്നതുപോലെ, ഫ്ലാഗുകൾ മാറുന്നത് കാണാൻ DEBUG നിങ്ങളെ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Each keystroke you type on the keyboard triggers an interrupt.","translation":"കീബോർഡിൽ നിങ്ങൾ ടൈപ്പ് ചെയ്യുന്ന ഓരോ കീസ്ട്രോക്കും ഒരു തടസ്സമുണ്ടാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If you disabled interrupts for any period of time, your real-time clock would stop and your keyboard would freeze up.","translation":"നിങ്ങൾ കുറച്ച് കാലത്തേക്ക് തടസ്സങ്ങൾ പ്രവർത്തനരഹിതമാക്കിയാൽ, നിങ്ങളുടെ തത്സമയ ക്ലോക്ക് നിലയ്ക്കുകയും കീബോർഡ് സ്തംഭിക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The assembler is unconcerned with what an assembly language variable means.","translation":"അസംബ്ലി ഭാഷാ വേരിയബിളിന്റെ അർത്ഥമെന്താണെന്നതിനെക്കുറിച്ച് അസംബ്ലറിന് യാതൊരു താൽപ്പര്യവുമില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Register data always has a fixed and obvious type, since a register's size cannot be changed.","translation":"രജിസ്റ്ററുകളുടെ വലുപ്പം മാറ്റാൻ കഴിയാത്തതിനാൽ, രജിസ്റ്റർ ഡാറ്റയ്ക്ക് എപ്പോഴും സ്ഥിരവും വ്യക്തവുമായ ഒരു തരം ഉണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You must match this type when you use the variable name Counter in an instruction to indicate memory data.","translation":"മെമ്മറി ഡാറ്റയെ സൂചിപ്പിക്കുന്ന ഒരു നിർദ്ദേശത്തിൽ വേരിയബിൾ നാമം കൗണ്ടർ ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾ ഈ തരം പൊരുത്തപ്പെടുത്തണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In real mode flat model, SS is set to the base of the stack segment by DOS when the program is loaded.","translation":"യഥാർത്ഥ മോഡ് ഫ്ലാറ്റ് മോഡിൽ, പ്രോഗ്രാം ലോഡ് ചെയ്യുമ്പോൾ DOS, സ്റ്റാക്ക് സെഗ്മെൻ്റിൻ്റെ അടിസ്ഥാനമായി SS സ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You set SS from the address of the segment that you define within the program in two steps.","translation":"പ്രോഗ്രാമിനുള്ളിൽ നിങ്ങൾ നിർവചിക്കുന്ന സെഗ്മെൻ്റിൻ്റെ വിലാസത്തിൽ നിന്ന് രണ്ട് ഘട്ടങ്ങളായി SS സ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Defining a stack segment just provides a starting point address for that segment.","translation":"ഒരു സ്റ്റാക്ക് സെഗ്മെൻ്റ് നിർവചിക്കുന്നത് ആ സെഗ്മെൻ്റിനായുള്ള ഒരു പ്രാരംഭ സ്ഥാന വിലാസം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can use RESB to reserve as much stack as you think you'll need.","translation":"നിങ്ങൾക്ക് ആവശ്യമുള്ളത്ര സ്റ്റാക്ക് റിസർവ് ചെയ്യാൻ RESB ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The stack in that model exists at the very highest addresses of the single segment the program lives in.","translation":"ആ മോഡലിലെ സ്റ്റാക്ക്, പ്രോഗ്രാം നിലനിൽക്കുന്ന ഒരൊറ്റ സെഗ്മെൻ്റിൻ്റെ ഏറ്റവും ഉയർന്ന വിലാസങ്ങളിൽ നിലനിൽക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"SP is set to the far end of the stack segment.","translation":"SP സ്റ്റാക്ക് സെഗ്മെൻ്റിൻ്റെ വിദൂര അറ്റത്തേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You have to set SP yourself.","translation":"നിങ്ങൾ തന്നെ SP സ്ഥാപിക്കണം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Pushing Data You can place data onto the stack in numerous ways.","translation":"ഡാറ്റ നൽകുക നിങ്ങൾക്ക് നിരവധി വഴികളിലൂടെ സ്റ്റാക്കിലേക്ക് ഡാറ്റ സ്ഥാപിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHF pushes the Flags register onto the stack.","translation":"PUSHF ഫ്ലാഗ്സ് രജിസ്റ്റർ സ്റ്റാക്കിലേക്ക് തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"PUSH pushes a 16-bit register or memory value that is specified by you in your source code.","translation":"PUSH നിങ്ങളുടെ സോഴ്സ് കോഡിൽ നിങ്ങൾ വ്യക്തമാക്കിയ 16-ബിറ്റ് രജിസ്റ്ററോ മെമ്മറി മൂല്യമോ തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"First SP is decremented by one word (two bytes) so that it points to an empty area of the stack segment.","translation":"ആദ്യം SP ഒരു വാക്ക് (രണ്ട് ബൈറ്റുകൾ) കുറയ്ക്കുന്നു, അതുവഴി അത് സ്റ്റാക്ക് സെഗ്മെൻ്റിൻ്റെ ഒഴിഞ്ഞ ഭാഗത്തേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"We call the word of memory pointed to by SP the top of the stack.","translation":"SP ചൂണ്ടിക്കാണിക്കുന്ന മെമ്മറിയുടെ വാക്കിനെ നമ്മൾ സ്റ്റാക്കിൻ്റെ മുകൾഭാഗം എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"PUSHA works the same way, except that it pushes eight 16-bit registers at once.","translation":"PUSHA അതേ രീതിയിൽ പ്രവർത്തിക്കുന്നു, എന്നാൽ ഇത് എട്ട് 16-ബിറ്റ് രജിസ്റ്ററുകൾ ഒരേസമയം തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"All memory between SP's initial position and its current position contains real data.","translation":"SP-യുടെ പ്രാരംഭ സ്ഥാനത്തിനും നിലവിലെ സ്ഥാനത്തിനും ഇടയിലുള്ള എല്ലാ മെമ്മറിയും യഥാർത്ഥ ഡാറ്റ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In real mode segmented model, the stack exists in a separate segment.","translation":"യഥാർത്ഥ മോഡ് സെഗ്മെൻ്റഡ് മോഡിൽ, സ്റ്റാക്ക് ഒരു പ്രത്യേക സെഗ്മെൻ്റിൽ നിലനിൽക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"What can and cannot be pushed onto the stack is complicated.","translation":"എന്താണ് സ്റ്റാക്കിലേക്ക് തള്ളാൻ കഴിയുക, എന്താണ് കഴിയാത്തത് എന്നത് സങ്കീർണ്ണമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In general, what gets pushed must get popped.","translation":"പൊതുവേ, എന്ത് തള്ളുന്നുവോ അത് പുറത്തേക്ക് എടുക്കണം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Getting a word of data off the stack is done with another trio of instructions, POP, POPF, and POPA.","translation":"സ്റ്റാക്കിൽ നിന്ന് ഒരു വാക്ക് ഡാറ്റ എടുക്കുന്നത് POP, POPF, POPA എന്നീ നിർദ്ദേശങ്ങളുടെ സഹായത്തോടെയാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"POP only operates on word-sized operands.","translation":"POP പ്രവർത്തിക്കുന്നത് വാക്ക് വലുപ്പത്തിലുള്ള ഓപ്പറാൻ്റുകളിൽ മാത്രമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"First the word of data at SS:SP is copied from the stack and placed in POP's operand.","translation":"ആദ്യം SS:SP-യിലെ ഡാറ്റയുടെ വാക്ക് സ്റ്റാക്കിൽ നിന്ന് പകർത്തി POP-യുടെ ഓപ്പറാൻ്റിൽ സ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The program EAT. ASM displays one (short) line of text on your display screen: Eat at Joe's!","translation":"EAT. ASM എന്ന പ്രോഗ്രാം നിങ്ങളുടെ സ്ക്രീനിൽ ഒരു (ചെറിയ) വരി പ്രദർശിപ്പിക്കുന്നു: Eat at Joe's!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"With no other computer language is there anything even close to the risk of writing code that looks so much like something scraped off the wall of King Tut's tomb.","translation":"മറ്റൊരു കമ്പ്യൂട്ടർ ഭാഷയിലും കിംഗ് ടട്ടിന്റെ ശവകുടീരത്തിൽ നിന്ന് ചുരണ്ടിയെടുത്തതുപോലെയുള്ള കോഡ് എഴുതുന്നതിലെ അപകടസാധ്യതയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The more comments you put in your file, the better you'll remember how things work inside the program the next time you pick it up.","translation":"നിങ്ങളുടെ ഫയലിൽ കൂടുതൽ കമന്റുകൾ ചേർക്കുമ്പോൾ, അടുത്ത തവണ പ്രോഗ്രാം എടുക്കുമ്പോൾ കാര്യങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുമെന്നത് നിങ്ങൾക്ക് ഓർമ്മിക്കാൻ എളുപ്പമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"I think you'll find it amazing how quickly the logic of a complicated assembly language file goes cold in your head.","translation":"ഒരു സങ്കീർണ്ണമായ അസംബ്ലി ഭാഷാ ഫയലിന്റെ ലോജിക് എത്ര വേഗമാണ് നിങ്ങളുടെ തലച്ചോറിൽ തണുക്കുന്നത് എന്ന് നിങ്ങൾ അത്ഭുതത്തോടെ കണ്ടെത്തും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Comments are neither time nor space wasted.","translation":"അഭിപ്രായങ്ങൾ സമയം പാഴാക്കുന്നില്ല, സ്ഥലവും പാഴാക്കുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"IBM used to say, One line of comments per line of code.","translation":"IBM പറയാറുണ്ടായിരുന്നു, ഓരോ കോഡിനും ഓരോ വരി അഭിപ്രായം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A better course (that I will in fact follow in the more complicated examples later on) is to use one short line of commentary to the right of each line of code, along with a comment block at the start of each sequence of instructions that work together in accomplishing some discrete task.","translation":"ഒരു നല്ല രീതി (കൂടുതൽ സങ്കീർണ്ണമായ ഉദാഹരണങ്ങളിൽ ഞാൻ പിന്നീട് പിന്തുടരും) ഓരോ കോഡിന്റെയും വലതുവശത്ത് ഒരു ചെറിയ കമന്റും, ചില പ്രത്യേക ടാസ്ക് ചെയ്യുന്ന നിർദ്ദേശങ്ങളുടെ ഓരോ ശ്രേണിയുടെയും തുടക്കത്തിൽ ഒരു കമന്റ് ബ്ലോക്കും ഉപയോഗിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The program EAT. ASM displays one (short) line of text on your display screen: Eat at Joe's!","translation":"EAT.ASM എന്ന പ്രോഗ്രാം നിങ്ങളുടെ സ്ക്രീനിൽ ഒരു (ചെറിയ) വരി പ്രദർശിപ്പിക്കുന്നു: Eat at Joe's!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The first thing you'll notice is that there are no references to segments or segment registers anywhere.","translation":"ആദ്യമായി നിങ്ങൾ ശ്രദ്ധിക്കുന്നത് സെഗ്മെന്റുകളോ സെഗ്മെന്റ് രജിസ്റ്ററുകളോ എവിടെയും പരാമർശിക്കുന്നില്ല എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The reason for this is that in real mode flat model, you are inside a single segment, and everything you do, you do within that single segment.","translation":"റിയൽ മോഡ് ഫ്ലാറ്റ് മോഡലിൽ, നിങ്ങൾ ഒരു സിംഗിൾ സെഗ്മെൻ്റിനുള്ളിലാണ്, നിങ്ങൾ ചെയ്യുന്നതെല്ലാം ആ സിംഗിൾ സെഗ്മെൻ്റിനുള്ളിലാണ് ചെയ്യുന്നത് എന്നതാണ് ഇതിന് കാരണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If everything happens within one single segment, the segments (in a sense) \"factor out\" and you can imagine that they don't exist.","translation":"എല്ലാം ഒരൊറ്റ സെഗ്മെൻ്റിനുള്ളിൽ സംഭവിച്ചാൽ, സെഗ്മെൻ്റുകൾ (ഒരു അർത്ഥത്തിൽ) \"ഫാക്ടർ ഔട്ട്\" ചെയ്യുകയും അവ നിലവിലില്ലെന്ന് നിങ്ങൾക്ക് സങ്കൽപ്പിക്കുകയും ചെയ്യാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Once we assemble EAT. ASM and create a runnable program from it, I'll show you what those segment registers are up to and how it is that you can almost ignore them in real mode flat model.","translation":"EAT. ASM അസംബിൾ ചെയ്ത് അതിൽ നിന്ന് പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു പ്രോഗ്രാം ഉണ്ടാക്കിയ ശേഷം, ആ സെഗ്മെൻ്റ് രജിസ്റ്ററുകൾ എന്താണ് ചെയ്യുന്നതെന്നും, റിയൽ മോഡ് ഫ്ലാറ്റ് മോഡലിൽ നിങ്ങൾക്ക് അവയെ എങ്ങനെ അവഗണിക്കാമെന്നും ഞാൻ കാണിച്ചു തരാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"At the top is a summary comment block.","translation":"മുകളിൽ ഒരു സംഗ്രഹ കമന്റ് ബ്ലോക്ക് ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This text is for your use only.","translation":"ഈ വാചകം നിങ്ങളുടെ ഉപയോഗത്തിന് മാത്രമുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When NASM processes a . ASM file, it strips out and discards all text between any semicolon and the end of the line the semicolon is in.","translation":"NASM ഒരു .ASM ഫയൽ പ്രോസസ്സ് ചെയ്യുമ്പോൾ, ഏതെങ്കിലും അർദ്ധവിരാമത്തിനും അർദ്ധവിരാമം വരുന്ന വരിയുടെ അവസാനത്തിനുമിടയിലുള്ള എല്ലാ വാചകങ്ങളും നീക്കം ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"I recommend placing a summary comment block like this at the top of every source code file you create.","translation":"നിങ്ങൾ ഉണ്ടാക്കുന്ന എല്ലാ സോഴ്സ് കോഡ് ഫയലിന്റെയും മുകളിൽ ഇതുപോലെയുള്ള ഒരു സംഗ്രഹ കമന്റ് ബ്ലോക്ക് സ്ഥാപിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Fill it with information that will help someone else understand the file you've written or that will help you understand the file later on, after it's gone cold in your mind.","translation":"നിങ്ങൾ എഴുതിയ ഫയൽ മറ്റൊരാൾക്ക് മനസ്സിലാക്കാനും അല്ലെങ്കിൽ നിങ്ങളുടെ മനസ്സിൽ തണുത്തുപോയ ശേഷം ഫയൽ മനസ്സിലാക്കാനും സഹായിക്കുന്ന വിവരങ്ങൾ ഇതിൽ ചേർക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Beneath the comment block is a short sequence of commands directed to the assembler.","translation":"കമന്റ് ബ്ലോക്കിന് താഴെ അസംബ്ലറിനായി നൽകിയിട്ടുള്ള കമാൻഡുകളുടെ ഒരു ചെറിയ ശ്രേണിയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The BITS command tells NASM that the program it's assembling is intended to be run in real mode, which is a 16-bit mode.","translation":"പ്രോഗ്രാം റിയൽ മോഡിൽ പ്രവർത്തിപ്പിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണെന്നും, അതൊരു 16-ബിറ്റ് മോഡ് ആണെന്നും BITS കമാൻഡ് NASM-നോട് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Using [BITS 32] instead would have brought into play all the marvelous 32-bit protected mode goodies introduced with the 386 and later x86 CPUs.","translation":"[BITS 32] ഉപയോഗിച്ചിരുന്നെങ്കിൽ 386-ലും അതിനുശേഷമുള്ള x86 CPU-കളിലും അവതരിപ്പിച്ച അത്ഭുതകരമായ 32-ബിറ്റ് പ്രൊട്ടക്റ്റഡ് മോഡ് സൗകര്യങ്ങൾ ലഭ്യമാകുമായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"NASM16 is the name of the version of NASM intended for use with real mode programs under DOS.","translation":"DOS-ൽ പ്രവർത്തിക്കുന്ന റിയൽ മോഡ് പ്രോഗ്രാമുകൾക്കായി ഉപയോഗിക്കാൻ ഉദ്ദേശിച്ചുള്ള NASM-ൻ്റെ പതിപ്പിൻ്റെ പേരാണ് NASM16.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"EAT. ASM is the name of the source code file you wish to assemble.","translation":"നിങ്ങൾ അസംബിൾ ചെയ്യാൻ ആഗ്രഹിക്കുന്ന സോഴ്സ് കോഡ് ഫയലിൻ്റെ പേരാണ് EAT.ASM.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The one we want is the . COM file, which is generated as a simple binary image of the generated machine-code bytes and any initialized data.","translation":"നമുക്ക് ആവശ്യമുള്ളത് .COM ഫയലാണ്, ഇത് ജനറേറ്റ് ചെയ്ത മെഷീൻ-കോഡ് ബൈറ്റുകളുടെയും ഏതെങ്കിലും ആരംഭിച്ച ഡാറ്റയുടെയും ലളിതമായ ബൈനറി ചിത്രമായി സൃഷ്ടിക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you don't specify the name of the output file, NASM will just lop off the \". ASM\" and call the file EAT.","translation":"ഔട്ട്പുട്ട് ഫയലിൻ്റെ പേര് നിങ്ങൾ നൽകിയില്ലെങ്കിൽ, NASM \".ASM\" നീക്കം ചെയ്യുകയും ഫയലിനെ EAT എന്ന് വിളിക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DOS treats its two kinds of executable programs a little differently when it runs them.","translation":"DOS, എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമുകളെ പ്രവർത്തിപ്പിക്കുമ്പോൾ അൽപ്പം വ്യത്യസ്തമായാണ് കൈകാര്യം ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":". COM files are a simple image of the instructions and data assembled out of the source code file.","translation":".COM ഫയലുകൾ, സോഴ്സ് കോഡ് ഫയലിൽ നിന്ന് അസംബിൾ ചെയ്ത നിർദ്ദേശങ്ങളുടെയും ഡാറ്റയുടെയും ലളിതമായ ചിത്രമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The . COM file is loaded into memory at a location of DOS's choosing.","translation":".COM ഫയൽ DOS തിരഞ്ഞെടുക്കുന്ന ഒരു ലൊക്കേഷനിൽ മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The instruction pointer IP is set to 0100H.","translation":"ഇൻസ്ട്രക്ഷൻ പോയിൻ്റർ IP 0100H ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The number of bytes loaded from disk and stored into memory is placed in the CX register.","translation":"ഡിസ്കിൽ നിന്ന് ലോഡ് ചെയ്ത് മെമ്മറിയിൽ സംഭരിച്ച ബൈറ്റുകളുടെ എണ്ണം CX രജിസ്റ്ററിൽ സ്ഥാപിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"All four segment registers CS, SS, DS, and ES are set to the same value: the segment address of the single segment in which the . COM program must run.","translation":"നാല് സെഗ്മെൻ്റ് രജിസ്റ്ററുകളും CS, SS, DS, ES എന്നിവ ഒരേ മൂല്യത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു: .COM പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കേണ്ട ഒരൊറ്റ സെഗ്മെൻ്റിൻ്റെ സെഗ്മെൻ്റ് വിലാസം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You'll sometimes hear the real mode flat model referred to as the Tiny model.","translation":"റിയൽ മോഡ് ഫ്ലാറ്റ് മോഡലിനെ ചിലപ്പോൾ ടൈനി മോഡൽ എന്ന് വിളിക്കുന്നത് നിങ്ങൾ കേട്ടിട്ടുണ്ടാകാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The main problem with real mode flat model is that everything you do must fit into 64K of memory.","translation":"റിയൽ മോഡ് ഫ്ലാറ്റ് മോഡലിൻ്റെ പ്രധാന പ്രശ്നം, നിങ്ങൾ ചെയ്യുന്നതെല്ലാം 64K മെമ്മറിയിൽ ഉൾക്കൊള്ളണം എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Let's do the Land Shark HyperBike trick again, this time with a version of EAT. ASM specifically written to use the real mode segmented model.","translation":"നമുക്ക് വീണ്ടും ലാൻഡ് ഷാർക്ക് ഹൈപ്പർബൈക്ക് ട്രിക്ക് ചെയ്യാം, ഇത്തവണ റിയൽ മോഡ് സെഗ്മെൻ്റഡ് മോഡൽ ഉപയോഗിക്കുന്നതിനായി പ്രത്യേകം എഴുതിയ EAT.ASM-ൻ്റെ ഒരു പതിപ്പ് ഉപയോഗിച്ച്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Assembly language programs written for real mode segmented model must contain at least three segments: One for code, one for data, and one for the stack.","translation":"റിയൽ മോഡ് സെഗ്മെൻ്റഡ് മോഡലിനായി എഴുതിയ അസംബ്ലി ലാംഗ്വേജ് പ്രോഗ്രാമുകളിൽ കുറഞ്ഞത് മൂന്ന് സെഗ്മെൻ്റുകളെങ്കിലും ഉണ്ടായിരിക്കണം: ഒന്ന് കോഡിനും, ഒന്ന് ഡാറ്റയ്ക്കും, ഒന്ന് സ്റ്റാക്കിനും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Each segment has a name: stack,data, and code, which indicate pretty clearly what the segment is for.","translation":"ഓരോ സെഗ്മെൻ്റിനും ഒരു പേരുണ്ട്: stack, data, code, ഇത് സെഗ്മെൻ്റ് എന്തിനാണെന്ന് വ്യക്തമായി സൂചിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The segment containing the stack has some special considerations attached to it, especially regarding the linking of several files together into one executable program.","translation":"സ്റ്റാക്ക് അടങ്ങിയ സെഗ്മെൻ്റിന് ചില പ്രത്യേക പരിഗണനകളുണ്ട്, പ്രത്യേകിച്ച് ഒന്നിലധികം ഫയലുകൾ ഒരു എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമായി ലിങ്ക് ചെയ്യുന്നതുമായി ബന്ധപ്പെട്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In the real mode segmented mode, the different segments are indeed different and distinct regions of memory and are not all the same place.","translation":"റിയൽ മോഡ് സെഗ്മെൻ്റഡ് മോഡിൽ, വ്യത്യസ്ത സെഗ്മെൻ്റുകൾ തീർച്ചയായും വ്യത്യസ്തവും, പ്രത്യേകവുമായ മെമ്മറി ഭാഗങ്ങളാണ്, അവയെല്ലാം ഒരേ സ്ഥലത്തല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"When the program begins running, DOS doesn't set the segment registers to anything.","translation":"പ്രോഗ്രാം പ്രവർത്തിക്കാൻ തുടങ്ങുമ്പോൾ, DOS സെഗ്മെൻ്റ് രജിസ്റ്ററുകൾ ഒന്നും തന്നെ നൽകുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Keep in mind that you can only load a segment register from a general-purpose register- you can't load it from anything else, either immediate data or memory data.","translation":"ഒരു പൊതു-ആവശ്യത്തിനുള്ള രജിസ്റ്ററിൽ നിന്ന് മാത്രമേ നിങ്ങൾക്ക് ഒരു സെഗ്മെൻ്റ് രജിസ്റ്റർ ലോഡ് ചെയ്യാൻ കഴിയൂ എന്ന് ഓർമ്മിക്കുക - ഉടനടി ഡാറ്റയിൽ നിന്നോ മെമ്മറി ഡാറ്റയിൽ നിന്നോ നിങ്ങൾക്ക് ഇത് ലോഡ് ചെയ്യാൻ കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"NASM does not know which segment is the code segment, nor which segment is the data segment, nor which segment is the stack segment.","translation":"NASM-ന് കോഡ് സെഗ്മെൻ്റ് ഏതാണെന്നും, ഡാറ്റാ സെഗ്മെൻ്റ് ഏതാണെന്നും, സ്റ്റാക്ക് സെഗ്മെൻ്റ് ഏതാണെന്നും അറിയില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In moving 09H into register AH, we tell the dispatcher which service we want performed.","translation":"09H എന്ന സംഖ്യ AH എന്ന രജിസ്റ്ററിലേക്ക് നീക്കുന്നതിലൂടെ, ഏത് സേവനമാണ് വേണ്ടതെന്ന് ഞങ്ങൾ ഡിസ്പാച്ചറെ അറിയിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is not the fastest nor in other ways the best way to display a string on the PC's screen, but it is most certainly the easiest.","translation":"ഒരു PC-യുടെ സ്ക്രീനിൽ ഒരു സ്ട്രിംഗ് പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഏറ്റവും വേഗതയേറിയതോ, മറ്റ് രീതികളിൽ ഏറ്റവും മികച്ചതോ ആയ മാർഗ്ഗമല്ല ഇത്, എന്നാൽ ഇത് തീർച്ചയായും ഏറ്റവും എളുപ്പമുള്ള ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DOS service 09H has a slightly odd requirement: That the end of the string be marked with a dollar sign ($).","translation":"DOS സേവനമായ 09H-ന് അല്പം വിചിത്രമായ ഒരവശ്യകതയുണ്ട്: സ്ട്രിംഗിന്റെ അവസാനം ഒരു ഡോളർ ചിഹ്നം ($) ഉപയോഗിച്ച് അടയാളപ്പെടുത്തണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is the easiest, but certainly not the best way to display text on the screen.","translation":"ഇത് ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗമാണ്, പക്ഷേ സ്ക്രീനിൽ ടെക്സ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിനുള്ള ഏറ്റവും മികച്ച മാർഗ്ഗമല്ല ഇത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"With the address of the string in DS:DX and service number 09H in AH, we take a trip to the dispatcher by executing INT 21H.","translation":"DS:DX-ൽ സ്ട്രിംഗിന്റെ വിലാസവും, AH-ൽ 09H എന്ന സേവന നമ്പറും ഉപയോഗിച്ച്, INT 21H എക്സിക്യൂട്ട് ചെയ്തുകൊണ്ട് ഞങ്ങൾ ഡിസ്പാച്ചറിലേക്ക് ഒരു യാത്ര പോകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"How do we get home again?","translation":"നമ്മൾ എങ്ങനെ വീണ്ടും വീട്ടിലെത്തും?","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"To get into DOS, a program looks in a completely reliable place for the address of where it wants to go: the address stored in vector 21H.","translation":"DOS-ലേക്ക് പ്രവേശിക്കാൻ, ഒരു പ്രോഗ്രാം പോകാൻ ആഗ്രഹിക്കുന്ന വിലാസത്തിനായി പൂർണ്ണമായും വിശ്വസനീയമായ ഒരിടത്ത് തിരയുന്നു: 21H എന്ന വെക്റ്ററിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This address takes execution deep into DOS, leaving the program sitting above DOS.","translation":"ഈ വിലാസം എക്സിക്യൂഷനെ DOS-ലേക്ക് ആഴത്തിൽ കൊണ്ടുപോകുന്നു, പ്രോഗ്രാം DOS-നു മുകളിൽ നിലനിർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"To continue execution where it left off prior to the INT 21 instruction, DOS has to look in a completely reliable place for the return address, and that completely reliable place is none other than the top of the stack.","translation":"INT 21 നിർദ്ദേശത്തിന് മുമ്പ് നിർത്തിയ സ്ഥലത്ത് എക്സിക്യൂഷൻ തുടരുന്നതിന്, DOS-ന് റിട്ടേൺ വിലാസത്തിനായി പൂർണ്ണമായും വിശ്വസനീയമായ ഒരിടം തിരയേണ്ടതുണ്ട്, ആ പൂർണ്ണമായും വിശ്വസനീയമായ സ്ഥലം, സ്റ്റാക്കിന്റെ മുകളിൽ അല്ലാതെ മറ്റൊന്നുമല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"I mentioned earlier (without much emphasis) that the INT 21 instruction pushes an address to the top of the stack before it launches off into the unknown.","translation":"INT 21 നിർദ്ദേശം, അത് അജ്ഞാതത്വത്തിലേക്ക് പോകുന്നതിന് മുമ്പ് ഒരു വിലാസം സ്റ്റാക്കിന്റെ മുകളിലേക്ക് തള്ളിയിടുമെന്ന് ഞാൻ നേരത്തെ സൂചിപ്പിച്ചു (അധികം ഊന്നൽ നൽകാതെ).","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This address is the address of the next instruction in line for execution: the instruction immediately following the INT 21 instruction.","translation":"ഈ വിലാസം എക്സിക്യൂഷനുള്ള അടുത്ത നിർദ്ദേശത്തിന്റെ വിലാസമാണ്: INT 21 നിർദ്ദേശത്തിന് തൊട്ടുപിന്നാലെയുള്ള നിർദ്ദേശം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The INT instruction pushes a return address onto the stack and then jumps to the address stored in a particular vector.","translation":"INT നിർദ്ദേശം ഒരു റിട്ടേൺ വിലാസം സ്റ്റാക്കിലേക്ക് തള്ളിയിടുന്നു, തുടർന്ന് ഒരു പ്രത്യേക വെക്റ്ററിൽ സംഭരിച്ചിരിക്കുന്ന വിലാസത്തിലേക്ക് പോകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The instruction is IRET (for Interrupt RETurn), and it completes this complex but reliable system of jumping to an address when you really don't know the address.","translation":"ഈ നിർദ്ദേശം IRET (Interrupt RETurn) ആണ്, കൂടാതെ വിലാസം ശരിക്കും അറിയില്ലാത്തപ്പോൾ ഒരു വിലാസത്തിലേക്ക് ജമ്പ് ചെയ്യുന്ന ഈ സങ്കീർണ്ണവും എന്നാൽ വിശ്വസനീയവുമായ സംവിധാനം ഇത് പൂർത്തിയാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"EAT. ASM uses DOS services to save it the trouble of writing its string data to the screen a byte at a time.","translation":"EAT. ASM അതിന്റെ സ്ട്രിംഗ് ഡാറ്റ ഓരോ ബൈറ്റായി സ്ക്രീനിൽ എഴുതുന്നതിനുള്ള ബുദ്ധിമുട്ട് ഒഴിവാക്കാൻ DOS സേവനങ്ങൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The address into DOS is at a known location in the interrupt vector table, and the return address is at a known location on the stack.","translation":"DOS-ലേക്കുള്ള വിലാസം, തടസ്സ വെക്റ്റർ പട്ടികയിലെ ഒരു അറിയപ്പെടുന്ന സ്ഥാനത്തും, റിട്ടേൺ വിലാസം, സ്റ്റാക്കിലെ ഒരു അറിയപ്പെടുന്ന സ്ഥാനത്തും ആണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Software interrupts evolved from an older mechanism that did involve some genuine interrupting: hardware interrupts.","translation":"സോഫ്റ്റ്വെയർ തടസ്സങ്ങൾ, യഥാർത്ഥ തടസ്സങ്ങൾ ഉൾക്കൊള്ളുന്ന പഴയൊരു സംവിധാനത്തിൽ നിന്നാണ് രൂപപ്പെട്ടത്: ഹാർഡ്വെയർ തടസ്സങ്ങൾ.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A hardware interrupt is your CPU's mechanism for paying attention to the world outside itself.","translation":"ഒരു ഹാർഡ്വെയർ തടസ്സം, പുറം ലോകത്തേക്ക് ശ്രദ്ധ ചെലുത്തുന്നതിനുള്ള നിങ്ങളുടെ CPU-വിന്റെ ഒരു രീതിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The CPU recognizes this tap as a hardware interrupt.","translation":"CPU ഈ ടാപ്പിനെ ഒരു ഹാർഡ്വെയർ തടസ്സമായി തിരിച്ചറിയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The only difference between hardware and software interrupts is in the event that triggers the trip through the interrupt vector table.","translation":"ഹാർഡ്വെയർ, സോഫ്റ്റ്വെയർ തടസ്സങ്ങൾ തമ്മിലുള്ള ഒരേയൊരു വ്യത്യാസം, തടസ്സ വെക്റ്റർ പട്ടികയിലൂടെയുള്ള യാത്രയെ പ്രേരിപ്പിക്കുന്ന സംഭവത്തിലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"With a software interrupt the triggering event is part of the software; that is, an INT instruction.","translation":"ഒരു സോഫ്റ്റ്വെയർ തടസ്സത്തിൽ, പ്രവർത്തനത്തിന് കാരണമാകുന്ന സംഭവം സോഫ്റ്റ്വെയറിന്റെ ഭാഗമാണ്; അതായത്, ഒരു INT നിർദ്ദേശം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Continue, and tool building is a very good way to hone your assembly language skills.","translation":"തുടരുക, ടൂൾ ഉണ്ടാക്കുന്നത് നിങ്ങളുടെ അസംബ്ലി ഭാഷാ വൈദഗ്ദ്ധ്യം മെച്ചപ്പെടുത്താനുള്ള നല്ലൊരു മാർഗ്ഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"On the other hand, a short sequence (5 to 10 instructions) that is only called once or perhaps twice within a middling program is a poor candidate for a procedure.","translation":"മറുവശത്ത്, ഒരു ഇടത്തരം പ്രോഗ്രാമിനുള്ളിൽ ഒന്നോ രണ്ടോ തവണ മാത്രം വിളിക്കപ്പെടുന്ന ഒരു ചെറിയ ശ്രേണി (5 മുതൽ 10 വരെ നിർദ്ദേശങ്ങൾ) ഒരു നടപടിക്രമത്തിന് അനുയോജ്യമല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You may find it useful to define large procedures that are called only once when your program becomes big enough to require breaking it down into functional chunks.","translation":"നിങ്ങളുടെ പ്രോഗ്രാം പ്രവർത്തനപരമായ ഭാഗങ്ങളായി വിഭജിക്കേണ്ടത്ര വലുതാകുമ്പോൾ, ഒരു തവണ മാത്രം വിളിക്കപ്പെടുന്ന വലിയ നടപടിക്രമങ്ങൾ നിർവചിക്കുന്നത് നിങ്ങൾക്ക് ഉപയോഗപ്രദമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A thousand-line assembly language program might split well into a sequence of 9 or 10 largish procedures.","translation":"ആയിരം വരികളുള്ള ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാം 9 അല്ലെങ്കിൽ 10 വലിയ നടപടിക്രമങ്ങളായി നന്നായി വിഭജിക്കാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is clean and readable and provides a necessary view from a height when you begin to approach a thousand-line assembly language program.","translation":"ഇത് വൃത്തിയുള്ളതും വായിക്കാൻ എളുപ്പമുള്ളതുമാണ്, കൂടാതെ ആയിരം വരികളുള്ള ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിനെ സമീപിക്കുമ്പോൾ ആവശ്യമായ ഒരു കാഴ്ച നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Remember that the Martians are always hiding somewhere close by, anxious to turn your program into unreadable hieroglyphics.","translation":"നിങ്ങളുടെ പ്രോഗ്രാമിനെ വായിക്കാൻ കഴിയാത്ത ചിത്രലിപികളാക്കി മാറ്റാൻ ആഗ്രഹിക്കുന്ന ചൊവ്വക്കാർ എപ്പോഴും എവിടെയെങ്കിലും ഒളിച്ചിരിക്കുന്നു എന്ന് ഓർമ്മിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There's no weapon against them with half the power of procedures.","translation":"നടപടിക്രമങ്ങളുടെ ശക്തിയുടെ പകുതിയുള്ള ഒരു ആയുധവും അവർക്കെതിരെയില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Using BIOS Services In the last chapter we looked closely at DOS services, which are accessed through the DOS services dispatcher.","translation":"BIOS സേവനങ്ങൾ ഉപയോഗിക്കുന്നു. കഴിഞ്ഞ അധ്യായത്തിൽ, DOS സേവനങ്ങളെക്കുറിച്ച് നമ്മൾ സൂക്ഷ്മമായി പരിശോധിച്ചു, അത് DOS സേവനങ്ങളുടെ ഡിസ്പാച്ചർ വഴി ആക്സസ് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The DOS dispatcher lives at the other end of software interrupt 21H and offers a tremendous list of services at the disposal of your programs.","translation":"DOS ഡിസ്പാച്ചർ സോഫ്റ്റ്വെയർ തടസ്സപ്പെടുത്തൽ 21H-ൻ്റെ മറുവശത്താണ് പ്രവർത്തിക്കുന്നത്, കൂടാതെ നിങ്ങളുടെ പ്രോഗ്രാമുകൾക്കായി നിരവധി സേവനങ്ങളും വാഗ്ദാനം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"There's another provider of services in your machine that lives even deeper than DOS: the ROM BIOS.","translation":"DOS-നേക്കാൾ ആഴത്തിൽ നിങ്ങളുടെ മെഷീനിൽ സേവനങ്ങൾ നൽകുന്ന മറ്റൊരാളുണ്ട്: ROM BIOS.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"ROM is an acronym for read-only memory, and it indicates memory chips whose contents are burned into their silicon and do not vanish when power is turned off.","translation":"ROM എന്നാൽ റീഡ്-ഓൺലി മെമ്മറിയുടെ ചുരുക്കെഴുത്താണ്, കൂടാതെ അതിന്റെ ഉള്ളടക്കം സിലിക്കണിൽ പതിപ്പിച്ച്, പവർ ഓഫ് ചെയ്യുമ്പോൾ പോലും മാഞ്ഞുപോകാത്ത മെമ്മറി ചിപ്പുകളെ ഇത് സൂചിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"BIOS is an acronym for Basic Input/Output System, and it is just that: a collection of fundamental routines for dealing with your computer's input and output peripherals.","translation":"BIOS എന്നാൽ ബേസിക് ഇൻപുട്ട്/ഔട്ട്പുട്ട് സിസ്റ്റത്തിന്റെ ചുരുക്കെഴുത്താണ്, നിങ്ങളുടെ കമ്പ്യൂട്ടറിന്റെ ഇൻപുട്ട്, ഔട്ട്പുട്ട് പെരിഫറലുകൾ എന്നിവ കൈകാര്യം ചെയ്യുന്നതിനുള്ള അടിസ്ഥാനപരമായ പ്രവർത്തനങ്ങളുടെ ഒരു ശേഖരം കൂടിയാണിത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"These include disk drives, displays, printers, and the like.","translation":"ഇവയിൽ ഡിസ്ക് ഡ്രൈവുകൾ, ഡിസ്പ്ലേകൾ, പ്രിന്ററുകൾ എന്നിവയും അതുപോലെ മറ്റു പലതും ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"DOS uses BIOS services as part of some of the services that it provides.","translation":"DOS, അത് നൽകുന്ന ചില സേവനങ്ങളുടെ ഭാഗമായി BIOS സേവനങ്ങൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Like DOS, BIOS services are accessed through software interrupts.","translation":"DOS-നെപ്പോലെ, BIOS സേവനങ്ങളും സോഫ്റ്റ്വെയർ തടസ്സങ്ങളിലൂടെയാണ് ആക്സസ് ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Unlike DOS, which channels nearly all requests for its services through the single interrupt 21H, BIOS uses numerous interrupts (about 10) and groups similar categories of services beneath the control of different interrupts.","translation":"DOS-ൽ നിന്ന് വ്യത്യസ്തമായി, അതിന്റെ എല്ലാ സേവന അഭ്യർത്ഥനകളും സിംഗിൾ തടസ്സപ്പെടുത്തൽ 21H-ലൂടെ കൈകാര്യം ചെയ്യുമ്പോൾ, BIOS നിരവധി തടസ്സങ്ങൾ (ഏകദേശം 10) ഉപയോഗിക്കുകയും വ്യത്യസ്ത തടസ്സങ്ങളുടെ നിയന്ത്രണത്തിൽ സമാനമായ വിഭാഗങ്ങളിലുള്ള സേവനങ്ങളെ ഗ്രൂപ്പുചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"For example, video display services are accessed through interrupt 10H, keyboard services come through interrupt 16H, printer services through interrupt 17H, and so on.","translation":"ഉദാഹരണത്തിന്, വീഡിയോ ഡിസ്പ്ലേ സേവനങ്ങൾ തടസ്സപ്പെടുത്തൽ 10H വഴിയും, കീബോർഡ് സേവനങ്ങൾ തടസ്സപ്പെടുത്തൽ 16H വഴിയും, പ്രിന്റർ സേവനങ്ങൾ തടസ്സപ്പെടുത്തൽ 17H വഴിയും ആക്സസ് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The overall method for using BIOS services, however, is very similar to that of DOS.","translation":"എങ്കിലും, BIOS സേവനങ്ങൾ ഉപയോഗിക്കുന്നതിനുള്ള മൊത്തത്തിലുള്ള രീതി DOS-ന്റേതിന് വളരെ സമാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You load a service number and sometimes other initial values into the registers and then execute an INT <n> instruction, where the n depends on the category of services you're requesting.","translation":"നിങ്ങൾ ഒരു സേവന നമ്പറും ചിലപ്പോൾ മറ്റ് പ്രാരംഭ മൂല്യങ്ങളും രജിസ്റ്ററുകളിലേക്ക് ലോഡ് ചെയ്യുകയും തുടർന്ന് INT <n> നിർദ്ദേശം എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു, ഇവിടെ n നിങ്ങൾ അഭ്യർത്ഥിക്കുന്ന സേവനങ്ങളുടെ വിഭാഗത്തെ ആശ്രയിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Nothing difficult about that at all.","translation":"അതിൽ ഒട്ടും ബുദ്ധിമുട്ടൊന്നുമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The program starts at the address 100h.","translation":"പ്രോഗ്രാം 100h വിലാസത്തിൽ ആരംഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This section contains the code.","translation":"ഈ ഭാഗത്ത് കോഡ് അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The program clears the screen.","translation":"പ്രോഗ്രാം സ്ക്രീൻ മായ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The cursor is positioned at 14H, 09H.","translation":"കഴ്സർ 14H, 09H സ്ഥാനത്ത് സ്ഥാപിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The program displays the first text line.","translation":"പ്രോഗ്രാം ആദ്യത്തെ ടെക്സ്റ്റ് ലൈൻ പ്രദർശിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The process is terminated using DOS service.","translation":"DOS സേവനം ഉപയോഗിച്ച് പ്രക്രിയ അവസാനിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Initialized data is stored in the data section.","translation":"ആരംഭിച്ച ഡാറ്റ ഡാറ്റാ വിഭാഗത്തിൽ സംഭരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The value of LRXY is 184FH.","translation":"LRXY-യുടെ വില 184FH ആണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you have a mono CRT, change the value.","translation":"നിങ്ങൾക്ക് മോണോ CRT ഉണ്ടെങ്കിൽ, മൂല്യം മാറ്റുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The program displays 'Eat at Joe's...'.","translation":"പ്രോഗ്രാം 'Eat at Joe's...' പ്രദർശിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Assembly language is big on bits.","translation":"അസംബ്ലി ഭാഷയിൽ ബിറ്റുകൾക്ക് വലിയ പ്രാധാന്യമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding your machine and tools is most important.","translation":"നിങ്ങളുടെ മെഷീനും ടൂളുകളും മനസ്സിലാക്കുക എന്നതാണ് ഏറ്റവും പ്രധാനം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Higher-level languages hide essential details.","translation":"ഉയർന്ന തലത്തിലുള്ള ഭാഷകൾ അത്യാവശ്യമായ വിശദാംശങ്ങൾ മറയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Bit mapping assigns meanings to individual bits.","translation":"ബിറ്റ് മാപ്പിംഗ് വ്യക്തിഗത ബിറ്റുകൾക്ക് അർത്ഥം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The AND instruction performs a logical operation.","translation":"AND നിർദ്ദേശം ഒരു ലോജിക്കൽ പ്രവർത്തനം നടത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The result replaces the first operand.","translation":"ഫലം ആദ്യത്തെ ഓപ്പറാൻഡിനെ മാറ്റിസ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Masking out bits is a major use of AND.","translation":"ബിറ്റുകൾ മാസ്ക് ചെയ്യുന്നത് AND-ൻ്റെ പ്രധാന ഉപയോഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The OR instruction is closely related to AND.","translation":"OR നിർദ്ദേശം AND-നോട് അടുത്ത ബന്ധമുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The XOR instruction performs exclusive OR.","translation":"XOR നിർദ്ദേശം എക്സ്ക്ലൂസീവ് OR നടത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The NOT instruction changes bits to their opposite state.","translation":"NOT നിർദ്ദേശം ബിറ്റുകളെ എതിർ ദിശയിലേക്ക് മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"It's nothing more than a simple text file containing the three commands you would need to type separately: two for the assembler and a third to link the two assembled files together into the finished . EXE program.","translation":"നിങ്ങൾ പ്രത്യേകം ടൈപ്പ് ചെയ്യേണ്ട മൂന്ന് കമാൻഡുകൾ അടങ്ങിയ ഒരു ലളിതമായ ടെക്സ്റ്റ് ഫയൽ മാത്രമാണിത്: അസംബ്ലറിനായി രണ്ടും, അസംബിൾ ചെയ്ത രണ്ട് ഫയലുകളെ പൂർണ്ണമായ .EXE പ്രോഗ്രാമായി ലിങ്ക് ചെയ്യുന്നതിന് മൂന്നാമത്തേതും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"To run this batch program, just type \"BUILD4\" at the DOS prompt.","translation":"ഈ ബാച്ച് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ, DOS പ്രൊംപ്റ്റിൽ \"BUILD4\" എന്ന് ടൈപ്പ് ചെയ്യുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You'll be able to follow the progress of the three program runs, including any error messages or warnings.","translation":"എന്തെങ്കിലും പിശക് സന്ദേശങ്ങളോ മുന്നറിയിപ്പുകളോ ഉൾപ്പെടെ, മൂന്ന് പ്രോഗ്രാം റണ്ണുകളുടെ പുരോഗതി നിങ്ങൾക്ക് പിന്തുടരാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare the code segments PUBLIC in all modules, and give them all the same name.","translation":"എല്ലാ മൊഡ്യൂളുകളിലെയും കോഡ് സെഗ്മെന്റുകൾ പരസ്യമായി പ്രഖ്യാപിക്കുക, കൂടാതെ അവയ്ക്കെല്ലാം ഒരേ പേര് നൽകുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare the data segments PUBLIC in all modules, and give them all the same name.","translation":"എല്ലാ മൊഡ്യൂളുകളിലെയും ഡാറ്റാ സെഗ്മെന്റുകൾ പരസ്യമായി പ്രഖ്യാപിക്കുക, കൂടാതെ അവയ്ക്കെല്ലാം ഒരേ പേര് നൽകുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare all exported procedures, entry points, and variables as GLOBAL.","translation":"എല്ലാ എക്സ്പോർട്ട് ചെയ്ത നടപടിക്രമങ്ങളും, എൻട്രി പോയിന്റുകളും, വേരിയബിളുകളും ഗ്ലോബൽ ആയി പ്രഖ്യാപിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Put the exported declaration statement inside the segment where the exported items are declared.","translation":"എക്സ്പോർട്ട് ചെയ്ത ഇനങ്ങൾ പ്രഖ്യാപിച്ചിട്ടുള്ള സെഗ്മെൻ്റിനുള്ളിൽ എക്സ്പോർട്ട് ചെയ്ത ഡിക്ലറേഷൻ സ്റ്റേറ്റ്മെൻ്റ് സ്ഥാപിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Declare all imported procedures, entry points, and variables as EXTERN.","translation":"എല്ലാ ഇറക്കുമതി ചെയ്ത നടപടിക്രമങ്ങളും, എൻട്രി പോയിന്റുകളും, വേരിയബിളുകളും എക്സ്റ്റേണൽ ആയി പ്രഖ്യാപിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Put the imported declaration statement inside the segment where the imported items are to be used.","translation":"ഇറക്കുമതി ചെയ്ത ഇനങ്ങൾ ഉപയോഗിക്കേണ്ട സെഗ്മെൻ്റിനുള്ളിൽ ഇറക്കുമതി ചെയ്ത ഡിക്ലറേഷൻ സ്റ്റേറ്റ്മെൻ്റ് സ്ഥാപിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Data is used in the data segment, code in the code segment.","translation":"ഡാറ്റാ സെഗ്മെൻ്റിൽ ഡാറ്റയും, കോഡ് സെഗ്മെൻ്റിൽ കോഡും ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Finally, don't forget to add the names of all external modules to the linker command line in the link step.","translation":"അവസാനമായി, ലിങ്ക് ഘട്ടത്തിൽ ലിങ്കർ കമാൻഡ് ലൈനിലേക്ക് എല്ലാ ബാഹ്യ മൊഡ്യൂളുകളുടെയും പേരുകൾ ചേർക്കാൻ മറക്കരുത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If this still seems fuzzy to you, follow VIDLIB. ASM and EAT4. ASM as a model.","translation":"ഇപ്പോഴും നിങ്ങൾക്ക് അവ്യക്തമായി തോന്നുന്നുണ്ടെങ്കിൽ, VIDLIB.ASM, EAT4.ASM എന്നിവ ഒരു മാതൃകയായി പിന്തുടരുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Certainly it would be worth beefing up VIDLIB. ASM by adding more screen control procedures.","translation":"തീർച്ചയായും കൂടുതൽ സ്ക്രീൻ നിയന്ത്രണ നടപടിക്രമങ്ങൾ ചേർത്ത് VIDLIB.ASM മെച്ചപ്പെടുത്തുന്നത് നന്നായിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Procedures are the most obvious way, and certainly the easiest to understand.","translation":"നടപടിക്രമങ്ങൾ ഏറ്റവും വ്യക്തമായ മാർഗ്ഗമാണ്, തീർച്ചയായും മനസ്സിലാക്കാൻ എളുപ്പവുമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Macros are a different breed of cat entirely.","translation":"മാക്രോകൾ തികച്ചും വ്യത്യസ്തമായ ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When the assembler encounters the macro label in a source code file, it replaces the macro label with the text lines that the macro label represents.","translation":"അസംബ്ലർ ഒരു സോഴ്സ് കോഡ് ഫയലിൽ മാക്രോ ലേബൽ കണ്ടെത്തുമ്പോൾ, മാക്രോ ലേബൽ പ്രതിനിധീകരിക്കുന്ന ടെക്സ്റ്റ് ലൈനുകൾ ഉപയോഗിച്ച് അത് മാറ്റിസ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This is called expanding the macro, because the name of the macro (occupying one text line) is replaced by several lines of text, which are then assembled just as though they had appeared in the source code file all along.","translation":"ഇതിനെ മാക്രോ വികസിപ്പിക്കുക എന്ന് വിളിക്കുന്നു, കാരണം മാക്രോയുടെ പേര് (ഒരു ടെക്സ്റ്റ് ലൈൻ ഉൾക്കൊള്ളുന്നത്) നിരവധി വരികളുള്ള ടെക്സ്റ്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു, തുടർന്ന് അവ സോഴ്സ് കോഡ് ഫയലിൽ ഉടനീളം പ്രത്യക്ഷപ്പെട്ടതുപോലെ അസംബിൾ ചെയ്യപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Macros bear some resemblance to include files in high-level languages such as Pascal.","translation":"പാസ്കൽ പോലുള്ള ഉയർന്ന തലത്തിലുള്ള ഭാഷകളിലെ ഉൾപ്പെടുത്തൽ ഫയലുകളുമായി മാക്രോകൾക്ക് ചില സാമ്യങ്ങളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You might think of a macro as an include file that's built right into the source code file.","translation":"ഒരു മാക്രോയെ സോഴ്സ് കോഡ് ഫയലിലേക്ക് നേരിട്ട് നിർമ്മിച്ച ഒരു ഉൾപ്പെടുത്തൽ ഫയലായി നിങ്ങൾക്ക് കണക്കാക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There are advantages to macros over procedures.","translation":"നടപടിക്രമങ്ങളെക്കാൾ മാക്രോകൾക്ക് ചില നേട്ടങ്ങളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Keeping cursor movement and screen-clearing routines in source code form in every single program you write is a waste of space.","translation":"കർസർ നീക്കവും, സ്ക്രീൻ ക്ലിയറിംഗ് റൂട്ടീനുകളും നിങ്ങൾ എഴുതുന്ന എല്ലാ പ്രോഗ്രാമുകളിലും സോഴ്സ് കോഡ് രൂപത്തിൽ നിലനിർത്തുന്നത് സ്ഥലത്തിന്റെ പാഴാക്കലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The answer is to break the utility procedures out into an external library that you can assemble only once.","translation":"ഉത്തരം, യൂട്ടിലിറ്റി നടപടിക്രമങ്ങൾ ഒരു ബാഹ്യ ലൈബ്രറിയിലേക്ക് മാറ്റുക എന്നതാണ്, അത് നിങ്ങൾക്ക് ഒരു തവണ മാത്രം അസംബിൾ ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is called modular programming, and it is an extremely effective tool for programming efficiently in any language.","translation":"ഇതിനെ മോഡുലാർ പ്രോഗ്രാമിംഗ് എന്ന് വിളിക്കുന്നു, കൂടാതെ ഏതൊരു ഭാഷയിലും കാര്യക്ഷമമായി പ്രോഗ്രാം ചെയ്യുന്നതിനുള്ള വളരെ ഫലപ്രദമായ ഒരു ഉപകരണമാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A program might consist of three or four separate .ASM files, each of which is assembled separately to a separate .OBJ file.","translation":"ഒരു പ്രോഗ്രാം മൂന്നോ നാലോ പ്രത്യേക .ASM ഫയലുകൾ ഉൾക്കൊള്ളുന്നു, അവയോരോന്നും പ്രത്യേകം .OBJ ഫയലിലേക്ക് അസംബിൾ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"To produce the final executable .EXE file, the linker weaves all of the .OBJ files together.","translation":"അന്തിമ എക്സിക്യൂട്ടബിൾ .EXE ഫയൽ നിർമ്മിക്കാൻ, ലിങ്കർ എല്ലാ .OBJ ഫയലുകളും ഒരുമിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Each .ASM file is considered a module, and each module contains one or more procedures and possibly some data definitions.","translation":"ഓരോ .ASM ഫയലും ഒരു മൊഡ്യൂളായി കണക്കാക്കപ്പെടുന്നു, കൂടാതെ ഓരോ മൊഡ്യൂളിലും ഒന്നോ അതിലധികമോ നടപടിക്രമങ്ങളും ചില ഡാറ്റാ നിർവചനങ്ങളും അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When all the declarations are done correctly, all of the modules may freely call one another.","translation":"എല്ലാ പ്രഖ്യാപനങ്ങളും ശരിയായി പൂർത്തിയാകുമ്പോൾ, എല്ലാ മൊഡ്യൂളുകൾക്കും പരസ്പരം സ്വതന്ത്രമായി വിളിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you reference a label in your program without defining that label anywhere in the program, the assembler will gleefully give you an error message.","translation":"നിങ്ങളുടെ പ്രോഗ്രാമിൽ ഒരു ലേബൽ നിർവചിക്കാതെ, പ്രോഗ്രാമിന്റെ എവിടെയെങ്കിലും ആ ലേബലിനെ പരാമർശിക്കുകയാണെങ്കിൽ, അസംബ്ലർ നിങ്ങൾക്ക് സന്തോഷത്തോടെ ഒരു പിശക് സന്ദേശം നൽകും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In modular programming, you're frequently going to be calling procedures that don't exist anywhere in the program that you're actually working on.","translation":"മോഡുലാർ പ്രോഗ്രാമിംഗിൽ, നിങ്ങൾ യഥാർത്ഥത്തിൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമിൽ എവിടെയുമില്ലാത്ത നടപടിക്രമങ്ങൾ നിങ്ങൾ പതിവായി വിളിക്കേണ്ടിവരും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The answer is to declare a procedure external.","translation":"ഒരു നടപടിക്രമം ബാഹ്യമാണെന്ന് പ്രഖ്യാപിക്കുക എന്നതാണ് ഇതിനുള്ള ഉത്തരം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This works very much like it sounds: The assembler is told that a given label will have to be found outside the program somewhere, in another module.","translation":"ഇത് കേൾക്കുന്നതുപോലെ തന്നെ പ്രവർത്തിക്കുന്നു: ഒരു പ്രത്യേക ലേബൽ പ്രോഗ്രാമിന് പുറത്ത്, മറ്റൊരു മൊഡ്യൂളിൽ എവിടെയെങ്കിലും കണ്ടെത്തേണ്ടതുണ്ടെന്ന് അസംബ്ലറിനോട് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You've promised the assembler that you'll provide it later, and the assembler accepts your promise and keeps going without flagging the undefined label.","translation":"നിങ്ങൾ പിന്നീട് ഇത് നൽകുമെന്ന് അസംബ്ലറിനോട് വാഗ്ദാനം ചെയ്തിട്ടുണ്ട്, കൂടാതെ നിർവചിക്കാത്ത ലേബൽ ഫ്ലാഗ് ചെയ്യാതെ തന്നെ അസംബ്ലർ നിങ്ങളുടെ വാഗ്ദാനം സ്വീകരിക്കുകയും മുന്നോട്ട് പോവുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Over in the other module where procedure ClrScr exists, it isn't enough just to define the procedure.","translation":"ClrScr എന്ന നടപടിക്രമം നിലവിലുള്ള മറ്റ് മൊഡ്യൂളിൽ, നടപടിക്രമം നിർവചിച്ചാൽ മാത്രം പോരാ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You have to warn the assembler that ClrScr will be referenced from outside the module.","translation":"ClrScr മൊഡ്യൂളിന് പുറത്ത് നിന്ന് റഫറൻസ് ചെയ്യപ്പെടുമെന്ന് നിങ്ങൾ അസംബ്ലറിനെ അറിയിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker does that during the link operation.","translation":"ലിങ്ക് പ്രവർത്തന സമയത്ത് ലിങ്കർ അത് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"After all, why call it a linker if it doesn't link anything?","translation":"എന്തെങ്കിലും ലിങ്ക് ചെയ്യാത്ത ഒന്നിനെ എന്തിനാണ് ലിങ്കർ എന്ന് വിളിക്കുന്നത്?","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"At link time, the linker takes the two .OBJ files generated by the assembler, one from your program and the other from the module containing ClrScr, and combines them into a single .EXE executable file.","translation":"ലിങ്ക് സമയത്ത്, ലിങ്കർ അസംബ്ലർ ഉണ്ടാക്കിയ രണ്ട് .OBJ ഫയലുകൾ എടുക്കുന്നു, ഒന്ന് നിങ്ങളുടെ പ്രോഗ്രാമിൽ നിന്നും മറ്റൊന്ന് ClrScr അടങ്ങിയ മൊഡ്യൂളിൽ നിന്നും, അവയെല്ലാം ഒരു .EXE എക്സിക്യൂട്ടബിൾ ഫയലായി സംയോജിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"When the .EXE file is loaded and run, the program can call ClrScr as cleanly and quickly as though both had been declared in the same source code file.","translation":".EXE ഫയൽ ലോഡ് ചെയ്ത് പ്രവർത്തിക്കുമ്പോൾ, ഒരേ സോഴ്സ് കോഡ് ഫയലിൽ രണ്ടും പ്രഖ്യാപിച്ചതുപോലെ തന്നെ പ്രോഗ്രാമിന് ClrScr-നെ വേഗത്തിലും എളുപ്പത്തിലും വിളിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This process is summarized in Figure 9.2.","translation":"ഈ പ്രക്രിയ ചിത്രം 9.2-ൽ സംഗ്രഹിച്ചിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Your program can declare a variable as GLOBAL, and that variable may then be used by any module in which the same variable name is declared as external with the EXTERN directive.","translation":"നിങ്ങളുടെ പ്രോഗ്രാമിന് ഒരു വേരിയബിൾ GLOBAL ആയി പ്രഖ്യാപിക്കാൻ കഴിയും, തുടർന്ന് അതേ വേരിയബിൾ നാമം EXTERN നിർദ്ദേശത്തിനൊപ്പം ബാഹ്യമായി പ്രഖ്യാപിച്ചിട്ടുള്ള ഏതൊരു മൊഡ്യൂളിനും ആ വേരിയബിൾ ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The low nybble of the value to be converted is now in DI.","translation":"പരിവർത്തനം ചെയ്യേണ്ട മൂല്യത്തിന്റെ താഴ്ന്ന നിബിൾ ഇപ്പോൾ DI-ൽ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The address of Digits is loaded into BX.","translation":"അക്കങ്ങളുടെ വിലാസം BX-ലേക്ക് ലോഡ് ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Then the appropriate digit character is copied from Digits into AH.","translation":"തുടർന്ന്, κατάλληλη അക്ക χαρακറ്റർ അക്കങ്ങളിൽ നിന്ന് AH-ലേക്ക് പകർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The whole trick of using a lookup table lies in the way the character in the table is addressed.","translation":"ഒരു ലുക്ക്അപ്പ് പട്ടിക ഉപയോഗിക്കുന്നതിലെ സൂത്രവിദ്യ, പട്ടികയിലെ പ്രതീകത്തെ അഭിസംബോധന ചെയ്യുന്ന രീതിയിലാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"MOV AH,BYTE [BX+DI] DS:BX points to the start of Digits, so [BX] would address the first character in Digits.","translation":"MOV AH,BYTE [BX+DI] DS:BX അക്കങ്ങളുടെ ആരംഭത്തിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു, അതിനാൽ [BX] അക്കങ്ങളിലെ ആദ്യത്തെ പ്രതീകത്തെ അഭിസംബോധന ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"To get at the desired digit, we must index into the lookup table by adding the offset into the table to BX.","translation":"ആവശ്യമായ അക്കം ലഭിക്കുന്നതിന്, BX-ലേക്ക് പട്ടികയിലെ ഓഫ്സെറ്റ് ചേർത്ത് ലുക്ക്അപ്പ് പട്ടികയിലേക്ക് സൂചിക നൽകണം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"There is an x86 addressing mode intended precisely for use with lookup tables, called base indexed addressing.","translation":"ലുക്ക്അപ്പ് പട്ടികകൾക്കായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത ഒരു x86 വിലാസ രീതിയുണ്ട്, ഇതിനെ ബേസ് ഇൻഡെക്സ്ഡ് അഡ്രസ്സിംഗ് എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"That sounds more arcane than it is; what it means is that instead of specifying a memory location at [BX], we add an index contained in register DI to BX and address a memory location at [BX+DI].","translation":"അത് കേൾക്കുമ്പോൾ അത്ര എളുപ്പമല്ലാത്ത ഒന്നായി തോന്നാം; ഇതിനർത്ഥം [BX]-ൽ ഒരു മെമ്മറി സ്ഥാനം വ്യക്തമാക്കുന്നതിനുപകരം, DI രജിസ്റ്ററിൽ അടങ്ങിയിരിക്കുന്ന ഒരു സൂചിക BX-ലേക്ക് ചേർക്കുകയും [BX+DI]-ൽ ഒരു മെമ്മറി സ്ഥാനത്തെ അഭിസംബോധന ചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"If you recall, we masked out all of DI but the four lowest bits of the byte we are converting.","translation":"ഓർമ്മയുണ്ടെങ്കിൽ, നമ്മൾ പരിവർത്തനം ചെയ്യുന്ന ബൈറ്റിന്റെ ഏറ്റവും താഴ്ന്ന നാല് ബിറ്റുകൾ ഒഴികെ DI-യിലെ എല്ലാം മാസ്ക് ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"These bits will contain some value from 0 through 0FH.","translation":"ഈ ബിറ്റുകളിൽ 0 മുതൽ 0FH വരെയുള്ള ചില മൂല്യങ്ങൾ ഉണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Digits contains the hexadecimal digit characters from 0 to F.","translation":"അക്കങ്ങളിൽ 0 മുതൽ F വരെയുള്ള ഹെക്സാഡെസിമൽ അക്ക പ്രതീകങ്ങൾ അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"By using DI as the index, the value in DI will select its corresponding digit character in Digits.","translation":"സൂചികയായി DI ഉപയോഗിക്കുന്നതിലൂടെ, DI-യിലെ മൂല്യം അക്കങ്ങളിലെ അതിന്റെ അനുബന്ധ അക്ക പ്രതീകം തിരഞ്ഞെടുക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"We are using the value in DI to look up its equivalent hexadecimal digit character in the lookup table Digits.","translation":"ലുക്ക്അപ്പ് പട്ടികയായ അക്കങ്ങളിൽ അതിന്റെ തത്തുല്യമായ ഹെക്സാഡെസിമൽ അക്ക പ്രതീകം തിരയുന്നതിന് നമ്മൾ DI-യിലെ മൂല്യം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"See Figure 10.4.","translation":"ചിത്രം 10.4 കാണുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"So far, we've read a character from the lookup table into AH.","translation":"ഇതുവരെ, നമ്മൾ ലുക്ക്അപ്പ് പട്ടികയിൽ നിന്ന് ഒരു പ്രതീകം AH-ലേക്ക് വായിച്ചു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Now, we use yet another addressing mode to move the character from AX back into the second character of the destination string, whose address was passed to Byte2Str in DS:SI.","translation":"ഇപ്പോൾ, ലക്ഷ്യസ്ഥാന സ്ട്രിംഗിന്റെ രണ്ടാമത്തെ പ്രതീകത്തിലേക്ക് AX-ൽ നിന്ന് പ്രതീകം നീക്കുന്നതിന് നമ്മൾ മറ്റൊരു വിലാസ രീതി ഉപയോഗിക്കുന്നു, ഇതിന്റെ വിലാസം DS:SI-ൽ Byte2Str-ലേക്ക് കൈമാറി.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This addressing mode is called indirect displacement addressing, though I question the wisdom of memorizing that term.","translation":"ഈ വിലാസ രീതിയെ ഇൻഡയറക്ട് ഡിസ്പ്ലേസ്മെന്റ് അഡ്രസ്സിംഗ് എന്ന് വിളിക്കുന്നു, എന്നാൽ ആ പദം മനഃപാഠമാക്കുന്നതിലെ ബുദ്ധിയെ ഞാൻ ചോദ്യം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The mode is nothing more than indirect addressing (that is, addressing the contents of memory at [SI]) with the addition of a literal displacement: MOV [SI+1],AH","translation":"ഈ രീതി, ഒരു ലിറ്ററൽ ഡിസ്പ്ലേസ്മെന്റ് ചേർത്ത ഇൻഡയറക്ട് അഡ്രസ്സിംഗിന് (അതായത്, [SI]-ൽ മെമ്മറിയുടെ ഉള്ളടക്കം അഭിസംബോധന ചെയ്യുന്നത്) തുല്യമാണ്: MOV [SI+1],AH","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Once this MOV is done, the first of the two nybbles passed to Byte2Str in AL has been converted to its character equivalent and stored in the destination string variable at DS:SI.","translation":"ഈ MOV പൂർത്തിയായാൽ, AL-ൽ Byte2Str-ലേക്ക് കൈമാറിയ രണ്ട് നിബിളുകളിൽ ആദ്യത്തേത് അതിന്റെ പ്രതീകത്തിന് തുല്യമായി പരിവർത്തനം ചെയ്യപ്പെടുകയും DS:SI-ൽ ലക്ഷ്യസ്ഥാന സ്ട്രിംഗ് വേരിയബിളിൽ സംഭരിക്കപ്പെടുകയും ചെയ്തു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Now we have to do it again, this time for the high nybble.","translation":"ഇപ്പോൾ നമ്മൾ ഇത് വീണ്ടും ചെയ്യണം, ഇത്തവണ ഉയർന്ന നിബിളിനായി.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Signed arithmetic in assembly language is complex and subtle.","translation":"അസംബ്ലി ഭാഷയിലെ ചിഹ്നമിട്ട ഗണിതം സങ്കീർണ്ണവും സൂക്ഷ്മവുമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Unsigned arithmetic, on the other hand, does not recognize negative numbers.","translation":"മറുവശത്ത്, ചിഹ്നമില്ലാത്ത ഗണിതം നെഗറ്റീവ് സംഖ്യകളെ അംഗീകരിക്കുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Signed values are thought of as being greater than or less than.","translation":"ചിഹ്നമിട്ട മൂല്യങ്ങൾ വലുതോ ചെറുതോ ആയി കണക്കാക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Unsigned values are thought of as being above or below.","translation":"ചിഹ്നമില്ലാത്ത മൂല്യങ്ങൾ മുകളിലോ താഴെയോ ആയി കണക്കാക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Table 10.6 summarizes the arithmetic jump mnemonics and their synonyms.","translation":"പട്ടിക 10.6 ഗണിത ജമ്പ് ന്യൂമോണിക്സും അവയുടെ പര്യായപദങ്ങളും സംഗ്രഹിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Any mnemonics containing the words above or below are for unsigned values.","translation":"മുകളിലോ താഴെയോ എന്ന വാക്കുകൾ ഉൾക്കൊള്ളുന്ന ഏതൊരു ന്യൂമോണിക്സും ചിഹ്നമില്ലാത്ത മൂല്യങ്ങൾക്കുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Compare the mnemonics with their synonyms and see how the two represent opposite viewpoints.","translation":"ന്യൂമോണിക്സുകളെ അവയുടെ പര്യായപദങ്ങളുമായി താരതമ്യം ചെയ്യുക, കൂടാതെ രണ്ടും എങ്ങനെ വിപരീത വീക്ഷണങ്ങൾ പ്രതിനിധീകരിക്കുന്നു എന്ന് കാണുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Table 10.7 sorts the mnemonics out by logical condition.","translation":"പട്ടിക 10.7 ന്യൂമോണിക്സുകളെ ലോജിക്കൽ അവസ്ഥ അനുസരിച്ച് അടുക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Notice that some of the jump instructions require one of two possible flag values.","translation":"ചില ജമ്പ് നിർദ്ദേശങ്ങൾക്ക് രണ്ട് ഫ്ലാഗ് മൂല്യങ്ങളിൽ ഒന്ന് ആവശ്യമാണെന്ന് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The second operand is subtracted from the first, and if the result is 0, the Zero flag is set to 1.","translation":"രണ്ടാമത്തെ ഓപ്പറാൻ്റ് ആദ്യത്തേതിൽ നിന്ന് കുറയ്ക്കുകയും, ഫലം 0 ആണെങ്കിൽ, സീറോ ഫ്ലാഗ് 1 ആയി സജ്ജീകരിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A useful example of CMP and the conditional jump instructions in action involves detecting the installed display adapter.","translation":"CMP-യുടെയും കണ്ടീഷണൽ ജമ്പ് നിർദ്ദേശങ്ങളുടെയും ഒരു ഉപയോഗപ്രദമായ ഉദാഹരണം, ഇൻസ്റ്റാൾ ചെയ്ത ഡിസ്പ്ലേ അഡാപ്റ്റർ കണ്ടെത്തുന്നത് ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The most obvious difference is that memory address of the video display buffer is one address for the color monitor and a different address for the monochrome monitor.","translation":"ഏറ്റവും വ്യക്തമായ വ്യത്യാസം, വീഡിയോ ഡിസ്പ്ലേ ബഫറിൻ്റെ മെമ്മറി വിലാസം കളർ മോണിറ്ററിന് ഒരു വിലാസവും, മോണോക്രോം മോണിറ്ററിന് മറ്റൊരു വിലാസവുമാണ് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In my method, I use a separate numeric code to represent each legal adapter/monitor combination.","translation":"എൻ്റെ രീതിയിൽ, ഓരോ നിയമപരമായ അഡാപ്റ്റർ/മോണിറ്റർ കോമ്പിനേഷനും പ്രതിനിധീകരിക്കുന്നതിന് ഞാൻ ഒരു പ്രത്യേക സംഖ്യാ കോഡ് ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The codes are not consecutive; note that there is no code 3, 6, or 9.","translation":"കോഡുകൾ തുടർച്ചയായവയല്ല; കോഡ് 3, 6, അല്ലെങ്കിൽ 9 എന്നിവയില്ല എന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The procedure DispID determines which display adapter is installed.","translation":"DispID ഏത് ഡിസ്പ്ലേ അഡാപ്റ്ററാണ് ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്നത് എന്ന് നിർണ്ണയിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DispID then returns one of the codes listed in Table 10.8.","translation":"DispID തുടർന്ന് പട്ടിക 10.8-ൽ ലിസ്റ്റ് ചെയ്തിട്ടുള്ള കോഡുകളിലൊന്ന് നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"I recommend that your programs define a byte-sized variable.","translation":"നിങ്ങളുടെ പ്രോഗ്രാമുകൾ ഒരു ബൈറ്റ് വലുപ്പമുള്ള വേരിയബിൾ നിർവചിക്കണമെന്ന് ഞാൻ ശുപാർശ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Given what I've told you about CMP and conditional jump instructions so far, see if you can follow the logic in DispID.","translation":"CMP-യെക്കുറിച്ചും കണ്ടീഷണൽ ജമ്പ് നിർദ്ദേശങ്ങളെക്കുറിച്ചും ഇതുവരെ ഞാൻ പറഞ്ഞ കാര്യങ്ങൾ വെച്ച്, DispID-യിലെ ലോജിക് പിന്തുടരാൻ കഴിയുമോ എന്ന് നോക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The overall strategy is not obvious and warrants some attention.","translation":"മൊത്തത്തിലുള്ള തന്ത്രം വ്യക്തമല്ലാത്തതും ശ്രദ്ധ അർഹിക്കുന്നതുമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The simplest way to find out what display board is installed in a machine is to ask the machine by querying BIOS services.","translation":"ഒരു മെഷീനിൽ ഏത് ഡിസ്പ്ലേ ബോർഡാണ് ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്നത് എന്ന് അറിയാനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം, BIOS സേവനങ്ങൾ വഴി മെഷീനോട് ചോദിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A feature without value in some applications, such as financial programming.","translation":"ചില ആപ്ലിക്കേഷനുകളിൽ, സാമ്പത്തിക പ്രോഗ്രാമിംഗ് പോലുള്ളവയിൽ, മൂല്യമില്ലാത്ത ഒരു സവിശേഷത.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Here's how you use DOS interrupt 21H service 40H: You must pass the offset address of the string in DX, the length of the string in CX, and a file handle in BX.","translation":"DOS ഇന്ററപ്റ്റ് 21H service 40H എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഇതാ: നിങ്ങൾ DX-ൽ സ്ട്രിംഗിന്റെ ഓഫ്സെറ്റ് വിലാസവും, CX-ൽ സ്ട്രിംഗിന്റെ നീളവും, BX-ൽ ഒരു ഫയൽ ഹാൻഡിലും നൽകണം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"By passing the handle of a disk-based text file to DOS service 40H, you can write text to a disk-based text file instead of to the screen.","translation":"ഒരു ഡിസ്ക് അടിസ്ഥാനമാക്കിയുള്ള ടെക്സ്റ്റ് ഫയലിന്റെ ഹാൻഡിൽ DOS service 40H-ലേക്ക് നൽകുന്നതിലൂടെ, നിങ്ങൾക്ക് സ്ക്രീനിലേക്ക് പകരം ഡിസ്ക് അടിസ്ഥാനമാക്കിയുള്ള ടെക്സ്റ്റ് ഫയലിലേക്ക് ടെക്സ്റ്റ് എഴുതാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output is by default directed to the screen display, but you can use various DOS commands to redirect standard output to other destinations, such as the printer or a disk file.","translation":"പ്ര standard് standardട്ട് ഡിഫോൾട്ടായി സ്ക്രീൻ ഡിസ്പ്ലേയിലേക്ക് നയിക്കപ്പെടുന്നു, എന്നാൽ പ്രിന്റർ അല്ലെങ്കിൽ ഡിസ്ക് ഫയൽ പോലുള്ള മറ്റ് ലക്ഷ്യസ്ഥാനങ്ങളിലേക്ക് സ്റ്റാൻഡേർഡ് outputട്ട് റീഡയറക്ട് ചെയ്യാൻ നിങ്ങൾക്ക് വിവിധ DOS കമാൻഡുകൾ ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Finally, here is the whole of the INFO. ASM program:","translation":"അവസാനമായി, ഇതാ INFO. ASM പ്രോഗ്രാം:","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This program demonstrates how lookup tables and numerous instructions are used.","translation":"ഈ പ്രോഗ്രാം ലുക്ക്അപ്പ് ടേബിളുകളും നിരവധി നിർദ്ദേശങ്ങളും എങ്ങനെ ഉപയോഗിക്കാമെന്ന് വ്യക്തമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Set code start address to 100h (COM file)","translation":"കോഡ് ആരംഭ വിലാസം 100h ആയി സജ്ജമാക്കുക (COM ഫയൽ)","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Load in screen control macro library","translation":"സ്ക്രീൻ നിയന്ത്രണ മാക്രോ ലൈബ്രറിയിൽ ലോഡ് ചെയ്യുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This is where program execution begins:","translation":"പ്രോഗ്രാം എക്സിക്യൂഷൻ ആരംഭിക്കുന്നത് ഇവിടെയാണ്:","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Initialize all video information variables","translation":"എല്ലാ വീഡിയോ വിവര വേരിയബിളുകളും ആരംഭിക്കുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Clear the screen","translation":"സ്ക്രീൻ മായ്ക്കുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Here we display the name of the program and its author:","translation":"ഇവിടെ ഞങ്ങൾ പ്രോഗ്രാമിന്റെ പേരും അതിന്റെ രചയിതാവിനെയും പ്രദർശിപ്പിക്കുന്നു:","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Display the program name","translation":"പ്രോഗ്രാം നാമം പ്രദർശിപ്പിക്കുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"display the author name","translation":"രചയിതാവിന്റെ പേര് പ്രദർശിപ്പിക്കുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Here we display the name of the installed video board:","translation":"ഇവിടെ ഇൻസ്റ്റാൾ ചെയ്ത വീഡിയോ ബോർഡിന്റെ പേര് ഞങ്ങൾ പ്രദർശിപ്പിക്കുന്നു:","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Select DOS file handle 1: Standard Output","translation":"DOS ഫയൽ ഹാൻഡിൽ 1 തിരഞ്ഞെടുക്കുക: സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The name strings are 27 bytes long","translation":"പേര് സ്ട്രിംഗുകൾ 27 ബൈറ്റുകളാണ്","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The string address is stored in BordName","translation":"സ്ട്രിംഗ് വിലാസം BordName-ൽ സംഭരിച്ചിരിക്കുന്നു","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Service 40H: Write string to file","translation":"Service 40H: ഫയലിലേക്ക് സ്ട്രിംഗ് എഴുതുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Call DOS to display to Standard Output","translation":"സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് പ്രദർശിപ്പിക്കുന്നതിന് DOS-നെ വിളിക്കുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Each entry in the OriginTbl lookup table is two bytes in size, whereas each entry in Digits was one byte in size.","translation":"OriginTbl എന്ന ലുക്ക്അപ്പ് പട്ടികയിലെ ഓരോ എൻട്രിയും രണ്ട് ബൈറ്റ് വലുപ്പമുള്ളതാണ്, അതേസമയം Digits-ൽ ഓരോ എൻട്രിയും ഒരു ബൈറ്റ് വലുപ്പമുള്ളതായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When table elements are more than one byte long, you have to multiply the index by the number of bytes in each table element, or the lookup won't find the correct table element.","translation":"പട്ടികാ മൂലകങ്ങൾ ഒന്നിലധികം ബൈറ്റുകൾ ഉള്ളപ്പോൾ, നിങ്ങൾ സൂചികയെ ഓരോ പട്ടികാ മൂലകത്തിലെയും ബൈറ്റുകളുടെ എണ്ണം കൊണ്ട് ഗുണിക്കണം, അല്ലെങ്കിൽ ലുക്ക്അപ്പ് ശരിയായ പട്ടികാ മൂലകം കണ്ടെത്തുകയില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Suppose you get a code 2 back from DispID, indicating that you have a CGA in the system.","translation":"DispID-യിൽ നിന്ന് നിങ്ങൾക്ക് കോഡ് 2 ലഭിച്ചാൽ, നിങ്ങളുടെ സിസ്റ്റത്തിൽ ഒരു CGA ഉണ്ടെന്ന് ഇത് സൂചിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Adding the 2 code to the starting address of the table (as we did with Digits) takes us to the start of the second element in the table.","translation":"പട്ടികയുടെ ആരംഭ വിലാസത്തിലേക്ക് 2 കോഡ് ചേർക്കുന്നത് (ഡിജിറ്റുകൾ ഉപയോഗിച്ച് ചെയ്തതുപോലെ) നമ്മെ പട്ടികയിലെ രണ്ടാമത്തെ മൂലകത്തിന്റെ തുടക്കത്തിലേക്ക് എത്തിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you scan down to find the table element associated with the CGA, you'll find that it starts at an offset of four from the start of the table.","translation":"CGA-യുമായി ബന്ധപ്പെട്ട പട്ടികാ മൂലകം കണ്ടെത്താൻ നിങ്ങൾ താഴേക്ക് സ്കാൻ ചെയ്യുകയാണെങ്കിൽ, അത് പട്ടികയുടെ തുടക്കത്തിൽ നിന്ന് നാല് സ്ഥാനത്ത് ആരംഭിക്കുമെന്ന് നിങ്ങൾ കണ്ടെത്തും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"To index into the table correctly, you have to add 4, not 2, to the offset address of the start of the table.","translation":"പട്ടികയിൽ ശരിയായി സൂചിക നൽകുന്നതിന്, പട്ടികയുടെ ആരംഭ സ്ഥാനത്തിന്റെ ഓഫ്സെറ്റ് വിലാസത്തിലേക്ക് 4 ചേർക്കണം, 2 അല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There is a general-purpose multiply instruction in the x86 CPU, but MUL is outrageously slow as machine instructions go.","translation":"x86 CPU-ൽ ഒരു പൊതു ആവശ്യത്തിനുള്ള ഗുണിത നിർദ്ദേശമുണ്ട്, എന്നാൽ മെഷീൻ നിർദ്ദേശങ്ങൾ പോകുമ്പോൾ MUL വളരെ മന്ദഗതിയിലുള്ളതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"When you need to multiply a value by some power of 2 (that is, 2, 4, 8, 16, 32, and so on), you can do it by using the shift left instruction, SHL.","translation":"ഒരു മൂല്യത്തെ 2-ന്റെ ശക്തി ഉപയോഗിച്ച് ഗുണിക്കണമെങ്കിൽ (അതായത്, 2, 4, 8, 16, 32, തുടങ്ങിയവ), നിങ്ങൾക്ക് SHL എന്ന ഷിഫ്റ്റ് ലെഫ്റ്റ് നിർദ്ദേശം ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Shifting a value to the left by one bit multiplies the overall value by 2.","translation":"ഒരു മൂല്യത്തെ ഒരു ബിറ്റ് ഇടത്തേക്ക് മാറ്റുന്നത് മൊത്തത്തിലുള്ള മൂല്യത്തെ 2 കൊണ്ട് ഗുണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Shifting a value to the left by two bits multiplies the value by 4.","translation":"ഒരു മൂല്യത്തെ രണ്ട് ബിറ്റുകൾ ഇടത്തേക്ക് മാറ്റുന്നത് മൂല്യത്തെ 4 കൊണ്ട് ഗുണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Shifting a value to the left by three bits multiplies the value by 8, and so on.","translation":"ഒരു മൂല്യത്തെ മൂന്ന് ബിറ്റുകൾ ഇടത്തേക്ക് മാറ്റുന്നത് മൂല്യത്തെ 8 കൊണ്ട് ഗുണിക്കുന്നു, ഇത് തുടരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Sharp readers may have guessed that shifting to the right divides by powers of two—and that's also correct.","translation":"വലത്തേക്ക് മാറ്റുന്നത് രണ്ടിന്റെ ശക്തി ഉപയോഗിച്ച് ഹരിക്കുന്നു എന്ന് സൂക്ഷ്മമായി വായിക്കുന്നവർക്ക് മനസ്സിലായിക്കാണും - അതും ശരിയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Shifting right by one bit divides by 2; shifting right by two bits divides by 4, and so on.","translation":"ഒരു ബിറ്റ് വലത്തേക്ക് മാറ്റുന്നത് 2 കൊണ്ട് ഹരിക്കുന്നു; രണ്ട് ബിറ്റുകൾ വലത്തേക്ക് മാറ്റുന്നത് 4 കൊണ്ട് ഹരിക്കുന്നു, ഇത് തുടരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The advantage to multiplying with shift instructions is that it's fast.","translation":"ഷിഫ്റ്റ് നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ഗുണിക്കുന്നതിൻ്റെ നേട്ടം, ഇത് വേഗതയുള്ളതാണ് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Even on the oldest and slowest x86 CPUs, shifting a byte-sized value in a register to the left by one bit takes only two machine cycles.","translation":"ഏറ്റവും പഴയതും, ഏറ്റവും വേഗത കുറഞ്ഞതുമായ x86 CPU-കളിൽ പോലും, ഒരു രജിസ്റ്ററിലെ ബൈറ്റ് വലുപ്പമുള്ള മൂല്യത്തെ ഒരു ബിറ്റ് ഇടത്തേക്ക് മാറ്റാൻ രണ്ട് മെഷീൻ സൈക്കിളുകൾ മാത്രമേ എടുക്കൂ.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Once the index is multiplied by two with SHL, the index is added to the starting address of the table, just as with Digits.","translation":"SHL ഉപയോഗിച്ച് സൂചിക രണ്ടും കൊണ്ട് ഗുണിച്ച ശേഷം, ഡിജിറ്റുകളിൽ ചെയ്തതുപോലെ, സൂചിക പട്ടികയുടെ ആരംഭ വിലാസത്തിലേക്ക് ചേർക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This illustrates how you can realize enormous speed advantages by structuring your tables properly.","translation":"നിങ്ങളുടെ പട്ടികകൾ ശരിയായി ക്രമീകരിക്കുന്നതിലൂടെ നിങ്ങൾക്ക് എങ്ങനെ വലിയ വേഗത നേടാനാകുമെന്ന് ഇത് ചിത്രീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Even if it means leaving a little wasted space at the end of each element, do your best to make the length of your table elements equal to some power of two.","translation":"ഓരോ മൂലകത്തിൻ്റെയും അവസാനം അൽപ്പം സ്ഥലം പാഴാകുമെങ്കിലും, നിങ്ങളുടെ പട്ടികാ മൂലകങ്ങളുടെ നീളം രണ്ടിന്റെ ശക്തിക്ക് തുല്യമാക്കാൻ പരമാവധി ശ്രമിക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Tables are about the handiest means at your disposal for grouping data together and organizing them.","translation":"ഡാറ്റ ഒരുമിപ്പിക്കാനും, അവയെ ക്രമീകരിക്കാനും, നിങ്ങളുടെ കൈവശമുള്ള ഏറ്റവും എളുപ്പമുള്ള മാർഗ്ഗമാണ് പട്ടികകൾ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Sometimes tables can be as simple as those I've just shown you, which are simply sequences of single values.","translation":"ചിലപ്പോൾ, ഞാൻ ഇപ്പോൾ കാണിച്ചതുപോലെ, ലളിതമായ ശ്രേണികളായ പട്ടികകളും ഉണ്ടാകാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"ES must be loaded with the segment address of the destination string.","translation":"ഗമ്യസ്ഥാനം സ്ട്രിംഗിന്റെ സെഗ്മെന്റ് വിലാസം ഉപയോഗിച്ച് ES ലോഡ് ചെയ്യണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DI must be loaded with the offset address of the destination string.","translation":"ലക്ഷ്യസ്ഥാന സ്ട്രിംഗിന്റെ ഓഫ്സെറ്റ് വിലാസം ഉപയോഗിച്ച് DI ലോഡ് ചെയ്യണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"CX must be loaded with the number of times the copy of AX is to be stored into the string.","translation":"AX-ന്റെ പകർപ്പ് സ്ട്രിംഗിൽ എത്ര തവണ സംഭരിക്കണം എന്നുള്ളത് CX-ൽ ലോഡ് ചെയ്യണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"AX must be loaded with the word value to be stored into the string.","translation":"സ്ട്രിംഗിലേക്ക് സംഭരിക്കേണ്ട വാക്ക് മൂല്യം AX-ൽ ലോഡ് ചെയ്യണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The word value in AX is copied to the word at ES:DI.","translation":"AX-ലെ വാക്ക് മൂല്യം ES:DI-യിലെ വാക്കിലേക്ക് പകർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DI is incremented by 2, such that ES:DI now points to the next word in memory.","translation":"DI 2-ൽ വർദ്ധിപ്പിക്കുന്നു, അതുവഴി ES:DI ഇപ്പോൾ മെമ്മറിയിലെ അടുത്ത വാക്കിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One copy of AX gets copied to one word in memory.","translation":"AX-ന്റെ ഒരു പകർപ്പ് മെമ്മറിയിലെ ഒരു വാക്കിലേക്ക് പകർത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The DI register is adjusted so that it'll be ready for the next time STOSW is executed.","translation":"അടുത്ത തവണ STOSW എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ റെഡിയായിരിക്കാൻ DI രജിസ്റ്റർ ക്രമീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"CX is not decremented by STOSW.","translation":"STOSW ഉപയോഗിച്ച് CX കുറയ്ക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"CX is decremented automatically only if you put the REP prefix in front of STOSW.","translation":"REP പ്രിഫിക്സ് STOSW-ന്റെ മുന്നിൽ വെച്ചാൽ മാത്രമേ CX സ്വയമേവ കുറയുകയുള്ളൂ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can safely execute a STOSW instruction.","translation":"നിങ്ങൾക്ക് STOSW നിർദ്ദേശം സുരക്ഷിതമായി നടപ്പിലാക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can execute other instructions before executing another STOSW.","translation":"മറ്റൊരു STOSW നടപ്പിലാക്കുന്നതിന് മുമ്പ് നിങ്ങൾക്ക് മറ്റ് നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"As long as you don't disturb ES, DI, or CX, you can do whatever you wish.","translation":"ES, DI, അല്ലെങ്കിൽ CX എന്നിവയെ ശല്യപ്പെടുത്തുന്നില്ലെങ്കിൽ, നിങ്ങൾക്ക് ഇഷ്ടമുള്ളതെന്തും ചെയ്യാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can change AX if you like, but the changed value will be copied into memory.","translation":"നിങ്ങൾക്ക് വേണമെങ്കിൽ AX മാറ്റാം, എന്നാൽ മാറിയ മൂല്യം മെമ്മറിയിലേക്ക് പകർത്തപ്പെടും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"To make STOSW fully automatic, just hang the REP prefix ahead of it.","translation":"STOSW പൂർണ്ണമായും ഓട്ടോമാറ്റിക് ആക്കുന്നതിന്, REP പ്രിഫിക്സ് അതിനു മുന്നിൽ ചേർക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It sets up the tightest of all tight loops completely inside the CPU.","translation":"ഇത് CPU-നുള്ളിൽ തന്നെ ഏറ്റവും ഇറുകിയ ലൂപ്പുകൾ സജ്ജീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Your whole destination string, however large, has been filled with copies of AX.","translation":"എത്ര വലുതാണെങ്കിലും നിങ്ങളുടെ ലക്ഷ്യസ്ഥാന സ്ട്രിംഗ് AX-ന്റെ പകർപ്പുകൾ കൊണ്ട് നിറഞ്ഞിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Man, now that's programming!","translation":"എന്തൊരു പ്രോഗ്രാമിംഗ്!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The video refresh buffer is not usually part of your data segment.","translation":"വീഡിയോ റിഫ്രഷ് ബഫർ സാധാരണയായി നിങ്ങളുടെ ഡാറ്റാ സെഗ്മെന്റിന്റെ ഭാഗമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Any time you need to reference something that exists outside the 64K boundaries of a real mode flat model program, you're going to have to work with a far pointer.","translation":"റിയൽ മോഡ് ഫ്ലാറ്റ് മോഡൽ പ്രോഗ്രാമിന്റെ 64K പരിധിക്കുള്ളിൽ നിലനിൽക്കാത്ത ഒന്നിനെ നിങ്ങൾ റഫറൻസ് ചെയ്യേണ്ടിവരുമ്പോഴെല്ലാം, നിങ്ങൾ ഒരു വിദൂര പോയിന്ററുമായി പ്രവർത്തിക്കേണ്ടിവരും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The STOSW instruction is used to send the value in AX to the memory location ES:DI.","translation":"STOSW നിർദ്ദേശം ഉപയോഗിക്കുന്നത് AX-ൽ ഉള്ള മൂല്യം ES:DI എന്ന മെമ്മറി സ്ഥാനത്തേക്ക് അയയ്ക്കാൻ ആണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Incrementing AL changes the displayed character to the next one in line.","translation":"AL വർദ്ധിപ്പിക്കുന്നത് പ്രദർശിപ്പിക്കുന്ന പ്രതീകത്തെ അടുത്തതിലേക്ക് മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The AH half of AX contains the attribute byte.","translation":"AX-ൻ്റെ AH ഭാഗത്ത് ആട്രിബ്യൂട്ട് ബൈറ്റ് അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"BL is acting as a counter that governs the length of the lines of characters shown on the screen.","translation":"BL ഒരു കൗണ്ടറായി പ്രവർത്തിക്കുന്നു, ഇത് സ്ക്രീനിൽ കാണിക്കുന്ന പ്രതീകങ്ങളുടെ വരികളുടെ നീളം നിയന്ത്രിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"LOOPNZ watches both the state of the CX register and the state of the Zero flag ZF.","translation":"LOOPNZ, CX രജിസ്റ്ററിൻ്റെയും സീറോ ഫ്ലാഗ് ZF-ൻ്റെയും അവസ്ഥ നിരീക്ഷിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The inner loop is considered complete when we've displayed one full line of the ASCII table to the screen.","translation":"ASCII പട്ടികയുടെ ഒരു പൂർണ്ണമായ വരി സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുമ്പോൾ ആന്തരിക ലൂപ്പ് പൂർത്തിയായതായി കണക്കാക്കപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"We modify DI to jump from the end of a completed line to the start of the next line at the left margin.","translation":"പൂർത്തിയായ വരിയുടെ അവസാനം മുതൽ ഇടത് മാർജിനിലെ അടുത്ത വരിയുടെ ആരംഭത്തിലേക്ക് പോകാൻ DI-ൽ മാറ്റം വരുത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The outer loop shoots lines of characters at the screen, by repeating the inner loop some number of times.","translation":"ബാഹ്യ ലൂപ്പ്, ആന്തരിക ലൂപ്പ് കുറച്ച് തവണ ആവർത്തിച്ച് സ്ക്രീനിൽ പ്രതീകങ്ങളുടെ വരികൾ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Individual instructions are important, but not nearly as important as the full context within which they work.","translation":"പ്രത്യേക നിർദ്ദേശങ്ങൾ പ്രധാനമാണ്, എന്നാൽ അവ പ്രവർത്തിക്കുന്ന പൂർണ്ണമായ പശ്ചാത്തലത്തിനത്രയും പ്രാധാന്യമില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You have the fundamentals of a really good and extremely fast toolkit of video routines for your assembly language programs.","translation":"നിങ്ങളുടെ അസംബ്ലി ലാംഗ്വേജ് പ്രോഗ്രാമുകൾക്കായി വളരെ മികച്ചതും വേഗതയേറിയതുമായ വീഡിയോ ശൃംഖലകളുടെ അടിസ്ഥാന കാര്യങ്ങൾ നിങ്ങൾക്കുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A routine to move a string of characters from your data segment to the visible display buffer.","translation":"നിങ്ങളുടെ ഡാറ്റാ സെഗ്മെൻ്റിൽ നിന്ന് ദൃശ്യമായ ഡിസ്പ്ലേ ബഫറിലേക്ക് പ്രതീകങ്ങളുടെ ഒരു സ്ട്രിംഗ് നീക്കുന്നതിനുള്ള ഒരു ശൃംഖല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you've followed me this far, you've been exposed to nearly every concept commonly used in assembly language work.","translation":"നിങ്ങൾ എന്നെ ഇതുവരെ പിന്തുടർന്നിട്ടുണ്ടെങ്കിൽ, അസംബ്ലി ഭാഷാ ജോലികളിൽ സാധാരണയായി ഉപയോഗിക്കുന്ന മിക്കവാറും എല്ലാ ആശയങ്ങളും നിങ്ങൾക്ക് പരിചയപ്പെട്ടിട്ടുണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"DOS is simple, forgiving, and present in nearly all Windows machines either as a lurker-beneath- the-windows or a very high quality emulation.","translation":"DOS ലളിതവും, ക്ഷമയുള്ളതും, മിക്കവാറും എല്ലാ വിൻഡോസ് മെഷീനുകളിലും വിൻഡോസിൻ്റെ അടിയിൽ മറഞ്ഞിരിക്കുന്ന ഒന്നായോ അല്ലെങ്കിൽ വളരെ ഉയർന്ന നിലവാരമുള്ള അനുകരണമായോ കാണപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The relationship between Windows and its applications is much closer and far more complex.","translation":"വിൻഡോസും അതിൻ്റെ ആപ്ലിക്കേഷനുകളും തമ്മിലുള്ള ബന്ധം വളരെ അടുത്തതും കൂടുതൽ സങ്കീർണ്ണവുമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Coding a sizeable app could take a year.","translation":"വലിയൊരു ആപ്പ് കോഡ് ചെയ്യാൻ ഒരു വർഷമെടുത്തേക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Nothing beats assembly at speed and size, right?","translation":"വേഗതയുടെയും വലുപ്പത്തിൻ്റെയും കാര്യത്തിൽ അസംബ്ലിക്ക് മുന്നിൽ ആരുമില്ല, അല്ലേ?","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Today's C and Pascal compilers have gotten mighty damned good at generating near-optimal machine code.","translation":"ഇന്നത്തെ C, Pascal കംപൈലറുകൾ ഒപ്റ്റിമൽ മെഷീൻ കോഡ് ഉണ്ടാക്കുന്നതിൽ വളരെ മികച്ച നിലയിലെത്തിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The decision to cover Linux was not automatic.","translation":"ലിനക്സിനെക്കുറിച്ച് ഉൾപ്പെടുത്താനുള്ള തീരുമാനം യാന്ത്രികമായിരുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Linux is Unix, so any good beginner book on Unix will be useful.","translation":"ലിനക്സ്, യൂണിക്സാണ്, അതിനാൽ യൂണിക്സിനെക്കുറിച്ചുള്ള ഏതൊരു നല്ല തുടക്കക്കാരന്റെ പുസ്തകവും ഉപകാരപ്രദമാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If you've been using Linux as a programmer for more than half an hour, you've probably already glommed onto EMACS.","translation":"ഒരു പ്രോഗ്രാമറായി അര മണിക്കൂറിൽ കൂടുതൽ സമയം നിങ്ങൾ Linux ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, നിങ്ങൾ ഇതിനകം തന്നെ EMACS-ൽ എത്തിയിരിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"EMACS is way more than just an editor.","translation":"EMACS ഒരു എഡിറ്റർ എന്നതിലുപരി വളരെ കൂടുതലാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"It understands C syntax, C++ syntax, and assembly syntax.","translation":"ഇത് C സിന്റാക്സ്, C++ സിന്റാക്സ്, അസംബ്ലി സിന്റാക്സ് എന്നിവ മനസ്സിലാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"EMACS can build an executable from inside the editor.","translation":"എഡിറ്ററിനുള്ളിൽ നിന്ന് തന്നെ ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ ഉണ്ടാക്കാൻ EMACS-ന് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Whole books have been written on EMACS.","translation":"EMACS-നെക്കുറിച്ച് ധാരാളം പുസ്തകങ്ങൾ എഴുതിയിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If you intend to stick with Linux and do any significant programming for it, EMACS is indispensable.","translation":"നിങ്ങൾ Linux-ൽ തുടരാനും അതിനായി കാര്യമായ പ്രോഗ്രാമിംഗ് ചെയ്യാനും ഉദ്ദേശിക്കുന്നുണ്ടെങ്കിൽ, EMACS ഒഴിച്ചുകൂടാനാവാത്ത ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Learn as much of it as you can.","translation":"നിങ്ങൾക്ക് കഴിയുന്നത്ര പഠിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Most of Linux is written in C, and what little isn't in C is in assembly.","translation":"Linux-ൻ്റെ ഭൂരിഭാഗവും C-യിൽ എഴുതിയിരിക്കുന്നു, C-യിൽ ഇല്ലാത്തവ അസംബ്ലി ഭാഷയിലാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"So, before you attempt your first assembly program, buy a book and get down and hack some C.","translation":"അതിനാൽ, നിങ്ങളുടെ ആദ്യത്തെ അസംബ്ലി പ്രോഗ്രാം ആരംഭിക്കുന്നതിന് മുമ്പ്, ഒരു പുസ്തകം വാങ്ങി C കുറച്ച് പഠിക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You don't need to do a lot of it, but make sure you understand all the basic C concepts.","translation":"നിങ്ങൾ ഇത് ധാരാളം ചെയ്യേണ്ടതില്ല, എന്നാൽ എല്ലാ അടിസ്ഥാന C ആശയങ്ങളും മനസ്സിലാക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There are some excellent Pascal implementations for Linux, most of them free.","translation":"Linux-നായി മികച്ച ചില പാസ്കൽ നടപ്പാക്കലുകൾ ഉണ്ട്, അതിൽ കൂടുതലും സൗജന്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Go to the following Web site for more details and for the software itself.","translation":"കൂടുതൽ വിവരങ്ങൾക്കും സോഫ്റ്റ്വെയറിനുമായി താഴെ പറയുന്ന വെബ്സൈറ്റ് സന്ദർശിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"NASM for Linux Another (minor) reason that I chose NASM as the focus assembler for this book is that a very good implementation-still free-exists for Linux.","translation":"ഈ പുസ്തകത്തിനായി NASM-നെ ഒരു പ്രധാന അസംബ്ലറായി തിരഞ്ഞെടുത്തതിനുള്ള (ചെറിയ) മറ്റൊരു കാരണം, Linux-നായി ഇപ്പോഴും സൗജന്യമായി ലഭ്യമായ വളരെ നല്ല ഒരു നടപ്പാക്കൽ ഉണ്ട് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Installing the RPM file might seem to be easier, but there's a catch.","translation":"RPM ഫയൽ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് എളുപ്പമായി തോന്നാം, പക്ഷേ ഒരു പ്രശ്നമുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Installing NASM's Source Code Don't faint, newcomers.","translation":"NASM-ൻ്റെ സോഴ്സ് കോഡ് ഇൻസ്റ്റാൾ ചെയ്യുക, തുടക്കക്കാർ ആരുംതന്നെ പരിഭ്രമിക്കേണ്ടതില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It's not that hard, and rebuilding tools is a fact of Linux life.","translation":"അത്ര ബുദ്ധിമുട്ടുള്ള കാര്യമല്ല, ടൂളുകൾ വീണ്ടും ഉണ്ടാക്കുന്നത് Linux-ൻ്റെ ഒരു ഭാഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The configure step looks at your system, sees what C compilers you have installed, and tests those it finds for suitability.","translation":"configure ഘട്ടം നിങ്ങളുടെ സിസ്റ്റം പരിശോധിച്ച്, നിങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്ത C കംപൈലറുകൾ ഏതൊക്കെയാണെന്ന് കണ്ടെത്തി, അവയുടെ അനുയോജ്യത പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This will do a lot, though it won't take a great deal of time.","translation":"ഇത് ധാരാളം കാര്യങ്ങൾ ചെയ്യും, എന്നാൽ കൂടുതൽ സമയം എടുക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Free software never dies, though it sometimes gets a little dusty.","translation":"സൗജന്യ സോഫ്റ്റ്വെയർ ഒരിക്കലും നശിക്കില്ല, ചിലപ്പോൾ അൽപ്പം പഴകിയേക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"What's GNU?","translation":"എന്താണ് GNU?","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If you're going to program under Linux, regardless of what language you're using, you will eventually use one or more of the GNU tools.","translation":"നിങ്ങൾ Linux-ൽ പ്രോഗ്രാം ചെയ്യാൻ പോവുകയാണെങ്കിൽ, നിങ്ങൾ ഏത് ഭാഷയാണ് ഉപയോഗിക്കുന്നതെങ്കിലും, നിങ്ങൾ ഒടുവിൽ GNU ടൂളുകളിൽ ഒന്ന് അല്ലെങ്കിൽ അതിലധികമോ ഉപയോഗിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A numeric literal, when used in an assembly language instruction, is called immediate data.","translation":"അസംബ്ലി ഭാഷാ നിർദ്ദേശത്തിൽ ഉപയോഗിക്കുമ്പോൾ ഒരു സംഖ്യാ ലിറ്ററലിനെ ഉടനടി ഡാറ്റ എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When the macro is expanded, the argument you pass to the macro is substituted into the actual instruction that uses a macro argument, just as you passed it to the macro.","translation":"മാക്രോ വികസിപ്പിക്കുമ്പോൾ, നിങ്ങൾ മാക്രോയിലേക്ക് നൽകുന്ന ആർഗ്യുമെന്റ്, നിങ്ങൾ മാക്രോയിലേക്ക് നൽകിയത് പോലെ, ഒരു മാക്രോ ആർഗ്യുമെന്റ് ഉപയോഗിക്കുന്ന യഥാർത്ഥ നിർദ്ദേശത്തിലേക്ക് മാറ്റപ്പെടും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In other words, if you pass the value 10 in the %5 argument (ScreenY), the instruction MOV AL,%5 becomes MOV AL,10 once the macro is expanded by the assembler.","translation":"മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, നിങ്ങൾ %5 ആർഗ്യുമെന്റിൽ (സ്ക്രീൻ വൈ) 10 എന്ന മൂല്യം നൽകുകയാണെങ്കിൽ, അസംബ്ലർ മാക്രോ വികസിപ്പിച്ച ശേഷം MOV AL,%5 എന്ന നിർദ്ദേശം MOV AL,10 ആയി മാറും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"But if you pass the literal value 80 in the %3 argument (ScreenW), you cannot use IMUL %3, because after expansion this becomes IMUL 80, which is not a legal instruction on anything older than the 386.","translation":"എന്നാൽ നിങ്ങൾ %3 ആർഗ്യുമെന്റിൽ (സ്ക്രീൻഡബ്ല്യു) 80 എന്ന ലിറ്ററൽ മൂല്യം നൽകുകയാണെങ്കിൽ, നിങ്ങൾക്ക് IMUL %3 ഉപയോഗിക്കാൻ കഴിയില്ല, കാരണം വിപുലീകരണത്തിന് ശേഷം ഇത് IMUL 80 ആയി മാറുന്നു, ഇത് 386-നേക്കാൾ പഴയ ഒന്നിനും നിയമപരമായ നിർദ്ദേശമല്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The problem is not that you're using macro arguments with IMUL.","translation":"നിങ്ങൾ IMUL ഉപയോഗിച്ച് മാക്രോ ആർഗ്യുമെന്റുകൾ ഉപയോഗിക്കുന്നതല്ല പ്രശ്നം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The problem is that you're passing a numeric literal in a macro argument to an instruction that (in the form we're using it) cannot accept immediate data.","translation":"പ്രശ്നം, ഒരു മാക്രോ ആർഗ്യുമെന്റിൽ ഒരു സംഖ്യാ ലിറ്ററൽ, ഉടനടി ഡാറ്റ സ്വീകരിക്കാൻ കഴിയാത്ത ഒരു നിർദ്ദേശത്തിലേക്ക് (നമ്മൾ ഉപയോഗിക്കുന്ന രൂപത്തിൽ) നിങ്ങൾ കൈമാറുന്നു എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The version of Ruler given in MYLIB. MAC loads the %3 (ScreenW) argument into AH using a MOV instruction.","translation":"MYLIB-ൽ നൽകിയിട്ടുള്ള റൂളറിന്റെ പതിപ്പ്. MAC, MOV നിർദ്ദേശം ഉപയോഗിച്ച് %3 (സ്ക്രീൻഡബ്ല്യു) ആർഗ്യുമെന്റ് AH-ലേക്ക് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This means that you can use numeric literals when invoking Ruler.","translation":"അതായത് റൂളർ വിളിക്കുമ്പോൾ നിങ്ങൾക്ക് സംഖ്യാ ലിറ്ററലുകൾ ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Using literals saves memory by making memory variables unnecessary, and if you'd prefer to define a meaningful name for the screen width rather than hard coding the value 80 in the source (which is unwise), you can define a symbol called ScreenWidth as an equate.","translation":"ലിറ്ററലുകൾ ഉപയോഗിക്കുന്നത് മെമ്മറി വേരിയബിളുകൾ അനാവശ്യമാക്കി മെമ്മറി ലാഭിക്കുന്നു, കൂടാതെ നിങ്ങൾ സോഴ്സിൽ 80 എന്ന മൂല്യം ഹാർഡ് കോഡ് ചെയ്യുന്നതിനുപകരം സ്ക്രീൻ വീതിക്ക് അർത്ഥവത്തായ ഒരു പേര് നൽകാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ (അത് വിവേകശൂന്യമാണ്), നിങ്ങൾക്ക് ScreenWidth എന്ന് പേരുള്ള ഒരു ചിഹ്നം ഒരു ഈക്വേറ്റ് ആയി നിർവചിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"I explained equates at the end of Chapter 10.","translation":"പത്താം അധ്യായത്തിന്റെ അവസാനത്തിൽ ഞാൻ ഈക്വേറ്റുകളെക്കുറിച്ച് വിശദീകരിച്ചു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The SHOWCHAR. ASM routine defines a ScreenWidth value as an equate.","translation":"SHOWCHAR. ASM റൂട്ടീൻ ഒരു ScreenWidth മൂല്യത്തെ ഒരു ഈക്വേറ്റ് ആയി നിർവചിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Adding ASCII Digits Once the correct offset into the buffer for the ruler's beginning is calculated in DI (and once we set up initial values for CX and AX), we're ready to start making rulers.","translation":"ആസ്കി അക്കങ്ങൾ ചേർക്കുന്നു, റൂളറിന്റെ തുടക്കത്തിനായി ബഫറിലേക്കുള്ള ശരിയായ ഓഫ്സെറ്റ് DI-യിൽ കണക്കാക്കിയ ശേഷം (കൂടാതെ CX, AX എന്നിവയ്ക്കുള്ള പ്രാരംഭ മൂല്യങ്ങൾ സ്ഥാപിച്ച ശേഷം), റൂളറുകൾ ഉണ്ടാക്കാൻ ഞങ്ങൾ തയ്യാറാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Immediately before the STOSW instruction, we load the ASCII digit '1' into AL.","translation":"STOSW നിർദ്ദേശത്തിന് തൊട്ടുമുന്പ്, ആസ്കി അക്കം '1' AL-ലേക്ക് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Note that the instruction MOV AL,'1' does not move the numeric value 01 into AL!","translation":"MOV AL,'1' എന്ന നിർദ്ദേശം 01 എന്ന സംഖ്യാ മൂല്യം AL-ലേക്ക് നീക്കുന്നില്ല എന്നത് ശ്രദ്ധിക്കുക!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The '1' is an ASCII character, and the character '1' (the \"one\" digit) has a numeric value of 31H, or 49 decimal.","translation":"'1' എന്നത് ഒരു ASCII പ്രതീകമാണ്, കൂടാതെ '1' എന്ന പ്രതീകത്തിന് ( ","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This becomes a problem immediately after we store the digit '1' into video memory with STOSW.","translation":"STOSW ഉപയോഗിച്ച് അക്കം '1' വീഡിയോ മെമ്മറിയിൽ സംഭരിച്ചതിന് തൊട്ടുപിന്നാലെ ഇത് ഒരു പ്രശ്നമായി മാറുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"After digit '1,' we need to display digit '2,' and to do that we need to change the value stored in AL from '1' to '2.'","translation":"'1' എന്ന അക്കത്തിനു ശേഷം, നമ്മൾ '2' എന്ന അക്കം പ്രദർശിപ്പിക്കേണ്ടതുണ്ട്, അതിനായി AL-ൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം '1'-ൽ നിന്ന് '2'-ലേക്ക് മാറ്റേണ്ടതുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Ordinarily, you can't just add '1' to '1' and get '2'; 31H + 31H will give you 62H, which (when seen as an ASCII character) is lowercase letter b, not '2'!","translation":"സാധാരണയായി, നിങ്ങൾക്ക് '1'-നോട് '1' കൂട്ടിച്ചേർത്ത് '2' ലഭിക്കില്ല; 31H + 31H നിങ്ങൾക്ക് 62H നൽകും, ഇത് (ഒരു ASCII പ്രതീകമായി കാണുമ്പോൾ) ചെറിയക്ഷരം b ആണ്, '2' അല്ല!","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"However, in this case the x86 instruction set comes to the rescue, in the form of a somewhat peculiar instruction called AAA, Adjust AL after BCD Addition.","translation":"എങ്കിലും, ഈ സാഹചര്യത്തിൽ x86 ഇൻസ്ട്രക്ഷൻ സെറ്റ് രക്ഷയ്ക്കെത്തുന്നത് AAA എന്ന് പേരുള്ള, BCD കൂട്ടിച്ചേർക്കലിന് ശേഷം AL ക്രമീകരിക്കുന്ന, അൽപ്പം വിചിത്രമായ ഒരു നിർദ്ദേശത്തിന്റെ രൂപത്തിലാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"What AAA does is allow us, in fact, to add ASCII character digits rather than numeric values.","translation":"AAA ചെയ്യുന്നത്, സംഖ്യാ മൂല്യങ്ങൾക്കുപകരം ASCII പ്രതീക അക്കങ്ങൾ ചേർക്കാൻ നമ്മെ അനുവദിക്കുന്നു എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The make utility knows when a compile or a link task needs to be done at all.","translation":"കംപൈൽ ചെയ്യേണ്ടതോ ലിങ്ക് ചെയ്യേണ്ടതോ ആയ ഒരു ടാസ്ക് എപ്പോഴാണ് ചെയ്യേണ്ടതെന്ന് make യൂട്ടിലിറ്റിക്ക് അറിയാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When a file is newer than all of the files that it depends upon, that file is said to be up to date.","translation":"ഒരു ഫയൽ, അതിനെ ആശ്രയിക്കുന്ന എല്ലാ ഫയലുകളെക്കാളും പുതിയതാണെങ്കിൽ, ആ ഫയൽ കാലികമാണ് എന്ന് പറയപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The make utility makes remembering any of this unnecessary.","translation":"ഇതൊന്നും ഓർമ്മിക്കേണ്ട ആവശ്യമില്ല എന്ന് make യൂട്ടിലിറ്റി ഉറപ്പാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Make figures it out and does only what must be done, no more, no less.","translation":"Make അത് കണ്ടുപിടിക്കുകയും, ചെയ്യേണ്ടത് മാത്രം ചെയ്യുകയും ചെയ്യുന്നു, കൂടുതൽ ചെയ്യുകയുമില്ല, കുറയ്ക്കുകയും ഇല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The EMACS source code editor has the power to invoke the make facility without forcing you to leave the editor.","translation":"EMACS സോഴ്സ് കോഡ് എഡിറ്ററിന്, എഡിറ്റർ വിട്ട് പോകാതെ തന്നെ make സൗകര്യം പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In the AT&T syntax, source and destination operands are placed in the opposite order from Intel syntax.","translation":"AT&T സിന്റാക്സിൽ, സോഴ്സ്, ഡെസ്റ്റിനേഷൻ ഓപ്പറാൻഡുകൾ Intel സിന്റാക്സിൽ നിന്ന് വ്യത്യസ്തമായ ക്രമത്തിലാണ് സ്ഥാപിച്ചിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Register names are always preceded by the percent symbol, %.","translation":"രജിസ്റ്റർ പേരുകൾക്ക് എപ്പോഴും ശതമാനം ചിഹ്നമായ % ഉണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In the AT&T syntax, immediate operands are always preceded by the dollar sign, $.","translation":"AT&T സിന്റാക്സിൽ, ഉടനടി ലഭിക്കുന്ന ഓപ്പറാൻഡുകൾക്ക് എപ്പോഴും ഡോളർ ചിഹ്നമായ $ ഉണ്ടാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When an instruction does not take operands (call, leave, ret), it does not have an operand-size suffix.","translation":"ഒരു നിർദ്ദേശത്തിന് ഓപ്പറാൻഡുകൾ (call, leave, ret) ആവശ്യമില്ലെങ്കിൽ, അതിന് ഓപ്പറാൻഡ്-സൈസ് സഫിക്സ് ഉണ്ടാകില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This is just another AT&T peccadillo to be aware of.","translation":"ഇതൊരു AT&T ശൈലിയാണ്, ഇത് ശ്രദ്ധിക്കേണ്ടതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The make utility looks at the make file, and it looks at the timestamps of all the source code and object code files.","translation":"make യൂട്ടിലിറ്റി make ഫയലും, എല്ലാ സോഴ്സ് കോഡിൻ്റെയും ഒബ്ജക്റ്റ് കോഡ് ഫയലുകളുടെയും ടൈംസ്റ്റാമ്പുകളും പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The challenge, of course, is correctly remembering which two files have changed.","translation":"ഏത് രണ്ട് ഫയലുകളാണ് മാറിയതെന്ന് കൃത്യമായി ഓർമ്മിക്കുക എന്നതാണ് വെല്ലുവിളി.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The two steps go together in virtually all cases.","translation":"ഈ രണ്ട് ഘട്ടങ്ങളും മിക്കവാറും എല്ലാ സാഹചര്യങ്ങളിലും ഒരുമിച്ചാണ് നടപ്പിലാക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This line tells us that the executable file linkbase depends on three object code files.","translation":"ഈ വരി, എക്സിക്യൂട്ടബിൾ ഫയലായ linkbase, മൂന്ന് ഒബ്ജക്റ്റ് കോഡ് ഫയലുകളെ ആശ്രയിച്ചിരിക്കുന്നു എന്ന് നമ്മോട് പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In most cases, programmers never see it and don't have to fool with it.","translation":"മിക്കപ്പോഴും, പ്രോഗ്രാമർമാർ ഇത് കാണാറില്ല, ഇതിൽ ഇടപെടേണ്ട കാര്യവുമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The make mechanism, however, has one more very important aspect: knowing whether the job as a whole actually has to be done at all.","translation":"എങ്കിലും, make മെക്കാനിസത്തിന് വളരെ പ്രധാനപ്പെട്ട ഒരുകാര്യം കൂടിയുണ്ട്: മൊത്തത്തിലുള്ള ജോലി ചെയ്യേണ്ടതുണ്ടോ എന്ന് അറിയുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The full makefile would contain nothing more than these two dependencies.","translation":"പൂർണ്ണമായ makefile-ൽ ഈ രണ്ട് ഡിപ്പൻഡൻസികൾ മാത്രമേ ഉണ്ടാകൂ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When you select Tools | Compile, EMACS will place the following command in the command line at the bottom of its window and wait for you to do something.","translation":"Tools | Compile തിരഞ്ഞെടുക്കുമ്പോൾ, EMACS താഴെയുള്ള കമാൻഡ് ലൈനിൽ കമാൻഡ് നൽകുകയും നിങ്ങൾ എന്തെങ്കിലും ചെയ്യുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The -k option instructs make to stop building any file in which an error occurs and to leave the previous copy of the target file undisturbed.","translation":"-k എന്ന ഓപ്ഷൻ, ഒരു പിശക് സംഭവിച്ചാൽ ഫയൽ ഉണ്ടാക്കുന്നത് നിർത്താനും, ടാർഗെറ്റ് ഫയലിൻ്റെ പഴയ പതിപ്പ് മാറ്റമില്ലാതെ സൂക്ഷിക്കാനും make-നെ പഠിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This actually makes a little more sense than Intel conventions, but confusion and errors are inevitable.","translation":"ഇത് Intel രീതികളെക്കാൾ അൽപ്പംകൂടി അർത്ഥവത്താണ്, പക്ഷേ ആശയക്കുഴപ്പങ്ങളും തെറ്റുകളും ഒഴിവാക്കാനാവാത്തതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In place of square brackets, AT&T uses parentheses to enclose the components of a memory address.","translation":"ചതുര ബ്രാക്കറ്റുകൾക്ക് പകരം, മെമ്മറി വിലാസത്തിന്റെ ഘടകങ്ങൾ ഉൾക്കൊള്ളുന്നതിന് AT&T പരാന്തസിസ് ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Here, we're moving the byte quantity at [ebx] to AL.","translation":"ഇവിടെ, [ebx]-ൽ ഉള്ള ബൈറ്റ് അളവ് AL-ലേക്ക് നീക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Don't forget that the order of operands is reversed from what Intel syntax does!","translation":"ഓർക്കുക, Intel സിന്റാക്സിൽ നിന്ന് വ്യത്യസ്തമായി, ഓപ്പറാൻഡുകളുടെ ക്രമം ഇവിടെ മാറ്റപ്പെട്ടിരിക്കുന്നു!","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Inside the parentheses you place the base, the index, and the scale, when present.","translation":"അടയാളത്തിനുള്ളിൽ, ബേസ്, ഇൻഡെക്സ്, സ്കെയിൽ എന്നിവ നൽകുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The displacement, when one exists, must go in front of and outside the parentheses.","translation":"ഡിസ്പ്ലേസ്മെന്റ് ഉണ്ടെങ്കിൽ, അത് പരാന്തസിസിനു മുന്നിലും പുറത്തും നൽകണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Note that in AT&T syntax, you don't do the math inside the parentheses.","translation":"AT&T സിന്റാക്സിൽ, പരാന്തസിസിനുള്ളിൽ ഗണിത ക്രിയകൾ ചെയ്യാൻ പാടില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The base, index, and scale are separated by commas, and plus signs and asterisks are not allowed.","translation":"ബേസ്, ഇൻഡെക്സ്, സ്കെയിൽ എന്നിവ കോമ ഉപയോഗിച്ച് വേർതിരിക്കുന്നു, കൂടാതെ പ്ലസ് ചിഹ്നവും, ആസ്റ്ററിക്സും അനുവദനീയമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The displacement value is optional.","translation":"ഡിസ്പ്ലേസ്മെന്റ് മൂല്യം ഓപ്ഷണലാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You may omit it entirely if there's no displacement in the memory reference.","translation":"മെമ്മറി റഫറൻസിൽ ഡിസ്പ്ലേസ്മെന്റ് ഇല്ലെങ്കിൽ, ഇത് പൂർണ്ണമായും ഒഴിവാക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"What you will see most of the time, however, is a very simple type of memory reference: −16(%ebp)","translation":"എന്നാൽ, നിങ്ങൾ മിക്കപ്പോഴും കാണുന്നത് വളരെ ലളിതമായ ഒരുതരം മെമ്മറി റഫറൻസാണ്: −16(%ebp)","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The displacements will vary, of course, but what this almost always means is that an instruction is referencing a data item somewhere on the stack.","translation":"ഡിസ്പ്ലേസ്മെന്റുകൾ തീർച്ചയായും വ്യത്യാസപ്പെടും, എന്നാൽ ഇതിനർത്ഥം ഒരു നിർദ്ദേശം സ്റ്റാക്കിലെവിടെയെങ്കിലും ഒരു ഡാറ്റാ ഇനത്തെ പരാമർശിക്കുന്നു എന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"C code allocates its variables on the stack, in a stack frame, and then references those variables by constant offsets from the value in EBP.","translation":"C കോഡ് അതിന്റെ വേരിയബിളുകൾ സ്റ്റാക്കിൽ, ഒരു സ്റ്റാക്ക് ഫ്രെയിമിൽ അനുവദിക്കുകയും, EBP-യിലെ മൂല്യത്തിൽ നിന്നുള്ള സ്ഥിരമായ ഓഫ്സെറ്റുകൾ വഴി ആ വേരിയബിളുകളെ പരാമർശിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"EBP acts as a \"thumb in the stack,\" and items on the stack may be referenced in terms of offsets (either positive or negative) away from EBP.","translation":"EBP ഒരു \"തമ്പ് ഇൻ ദ സ്റ്റാക്ക്\" ആയി പ്രവർത്തിക്കുന്നു, കൂടാതെ സ്റ്റാക്കിലുള്ള ഇനങ്ങളെ EBP-യിൽ നിന്നുള്ള ഓഫ്സെറ്റുകളുടെ (പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ്) അടിസ്ഥാനത്തിൽ പരാമർശിക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The preceding reference would tell a machine instruction to work with an item at the address in EBP minus 16 bytes.","translation":"മുമ്പത്തെ റഫറൻസ്, EBP-യിലെ വിലാസത്തിലുള്ള 16 ബൈറ്റുകൾ കുറച്ചുള്ള ഒരു ഇനത്തിൽ പ്രവർത്തിക്കാൻ ഒരു മെഷീൻ നിർദ്ദേശത്തോട് പറയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"I have a lot more to say about stack frames in the next chapter.","translation":"അടുത്ത അധ്യായത്തിൽ സ്റ്റാക്ക് ഫ്രെയിമുകളെക്കുറിച്ച് എനിക്ക് കൂടുതൽ പറയാനുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The first thing you have to understand about the GNU debugger gdb is that it was designed to work as a high-level debugger on C programs.","translation":"GNU ഡീബഗ്ഗർ gdb-യെക്കുറിച്ച് നിങ്ങൾ മനസ്സിലാക്കേണ്ട ആദ്യത്തെ കാര്യം, ഇത് C പ്രോഗ്രാമുകളിൽ ഒരു ഹൈ-ലെവൽ ഡീബഗ്ഗറായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്തതാണ് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"That is, gdb allows programmers to single-step a C program by stepping from one C statement to another, setting breakpoints on C statements, and so on.","translation":"അതായത്, gdb പ്രോഗ്രാമർമാരെ ഒരു C പ്രോഗ്രാമിന്റെ ഓരോ സ്റ്റേറ്റ്മെന്റിലും കടന്നുപോവാനും, C സ്റ്റേറ്റ്മെന്റുകളിൽ ബ്രേക്ക്പോയിന്റുകൾ സ്ഥാപിക്കാനും അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It isn't nearly as good as DOS DEBUG at poking around assembly code programs, or any programs at the binary level irrespective of their source language.","translation":"അസംബ്ലി കോഡ് പ്രോഗ്രാമുകളിലോ, അല്ലെങ്കിൽ സോഴ്സ് ഭാഷ പരിഗണിക്കാതെ തന്നെ, ബൈനറി തലത്തിലുള്ള ഏതെങ്കിലും പ്രോഗ്രാമുകളിലോ എത്തിനോക്കുന്നതിൽ DOS DEBUG-ന്റെ അത്രയും മികച്ചതല്ല ഇത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"If you're going to use a debugger to work on your assembly code, gdb will have to do.","translation":"നിങ്ങൾ അസംബ്ലി കോഡിൽ പ്രവർത്തിക്കാൻ ഒരു ഡീബഗ്ഗർ ഉപയോഗിക്കാൻ പോവുകയാണെങ്കിൽ, gdb ഉപയോഗിക്കേണ്ടിവരും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When you write a DOS assembly language program, as I explained in the earlier parts of this book, you write all of it.","translation":"നിങ്ങൾ ഒരു DOS അസംബ്ലി ലാംഗ്വേജ് പ്രോഗ്രാം എഴുതുമ്പോൾ, ഈ പുസ്തകത്തിന്റെ ആദ്യ ഭാഗങ്ങളിൽ ഞാൻ വിശദീകരിച്ചതുപോലെ, നിങ്ങൾ അതെല്ലാം എഴുതുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The debugger allows you to execute an assembly language program one instruction at a time.","translation":"അസംബ്ലി ഭാഷാ പ്രോഗ്രാം ഓരോ നിർദ്ദേശവും ഒന്നൊന്നായി നടപ്പിലാക്കാൻ ഡീബഗ്ഗർ നിങ്ങളെ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can examine both registers and program variables individually.","translation":"രജിസ്റ്ററുകളും പ്രോഗ്രാം വേരിയബിളുകളും നിങ്ങൾക്ക് വ്യക്തിഗതമായി പരിശോധിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The print command will display the value stored in any of the general-purpose registers.","translation":"ഏതെങ്കിലും പൊതു-ആവശ്യ രജിസ്റ്ററുകളിൽ സംഭരിച്ചിട്ടുള്ള മൂല്യം പ്രിന്റ് കമാൻഡ് പ്രദർശിപ്പിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The value history is a memory-based table in which gdb keeps values displayed using the print command.","translation":"പ്രിന്റ് കമാൻഡ് ഉപയോഗിച്ച് പ്രദർശിപ്പിച്ച മൂല്യങ്ങൾ gdb സൂക്ഷിക്കുന്ന മെമ്മറി അടിസ്ഥാനമാക്കിയുള്ള ഒരു പട്ടികയാണ് മൂല്യ ചരിത്രം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You can specify how the variable will be displayed with a format code.","translation":"ഒരു ഫോർമാറ്റ് കോഡ് ഉപയോഗിച്ച് വേരിയബിൾ എങ്ങനെ പ്രദർശിപ്പിക്കണമെന്ന് നിങ്ങൾക്ക് വ്യക്തമാക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can display a register or a variable in binary by using the t format code.","translation":"t ഫോർമാറ്റ് കോഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു രജിസ്റ്ററോ വേരിയബിളോ ബൈനറിയിൽ പ്രദർശിപ്പിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The print command has no way to display anything that won't fit in a character or integer value.","translation":"ഒരു പ്രതീകത്തിലോ പൂർണ്ണസംഖ്യാ മൂല്യത്തിലോ ഉൾക്കൊള്ളാത്ത ഒന്നും പ്രദർശിപ്പിക്കാൻ പ്രിന്റ് കമാൻഡിന് കഴിയില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"You must display null-terminated string variables with the x command.","translation":"x കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾ ശൂന്യമായ സ്ട്രിംഗ് വേരിയബിളുകൾ പ്രദർശിപ്പിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The x command can dump memory for a specified number of bytes beginning at a specified address.","translation":"നിർദ്ദിഷ്ട വിലാസത്തിൽ നിന്ന് ആരംഭിക്കുന്ന ഒരു നിശ്ചിത എണ്ണം ബൈറ്റുകൾക്കായി മെമ്മറി ഡംപ് ചെയ്യാൻ x കമാൻഡിന് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Changing values within machine registers and simple variables can be done with the print command.","translation":"മെഷീൻ രജിസ്റ്ററുകളിലെയും ലളിതമായ വേരിയബിളുകളിലെയും മൂല്യങ്ങൾ പ്രിന്റ് കമാൻഡ് ഉപയോഗിച്ച് മാറ്റാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The set var command will change the value of a variable without echoing the value back to you.","translation":"സെറ്റ് വേരിയബിൾ കമാൻഡ് മൂല്യം നിങ്ങൾക്ക് തിരികെ നൽകുന്നില്ലെങ്കിലും ഒരു വേരിയബിളിന്റെ മൂല്യം മാറ്റും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Patching memory at arbitrary addresses is something you may need to do from time to time.","translation":"ആവശ്യമുള്ള സമയങ്ങളിൽ, ഇഷ്ടമുള്ള വിലാസങ്ങളിൽ മെമ്മറി പാച്ച് ചെയ്യുന്നത് നിങ്ങൾ ചെയ്യേണ്ട ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Perhaps the most important job of a debugger is to let you execute an assembly language program one instruction at a time.","translation":"ഒരു അസംബ്ലി ഭാഷാ പ്രോഗ്രാം ഓരോ നിർദ്ദേശവും ഒന്നൊന്നായി നടപ്പിലാക്കാൻ അനുവദിക്കുക എന്നതാണ് ഒരു ഡീബഗ്ഗറുടെ ഏറ്റവും പ്രധാനപ്പെട്ട ജോലി.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The program is still running, but gdb has seized control of the machine.","translation":"പ്രോഗ്രാം ഇപ്പോഴും പ്രവർത്തിക്കുന്നുണ്ട്, എന്നാൽ gdb മെഷീന്റെ നിയന്ത്രണം ഏറ്റെടുത്തിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can continue program execution at full speed.","translation":"പ്രോഗ്രാം പൂർണ്ണ വേഗതയിൽ പ്രവർത്തിപ്പിക്കാൻ നിങ്ങൾക്ക് കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can also pick up execution with the until command.","translation":"അതുപോലെ, നിങ്ങൾക്ക് until കമാൻഡ് ഉപയോഗിച്ച് എക്സിക്യൂഷൻ എടുക്കാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Single-stepping is simple in principle: You type a gdb command that executes a single machine instruction.","translation":"ഒറ്റയൊറ്റ സ്റ്റെപ്പിംഗ് തത്വം ലളിതമാണ്: നിങ്ങൾ ഒരു gdb കമാൻഡ് ടൈപ്പ് ചെയ്യുമ്പോൾ അത് ഒരു മെഷീൻ നിർദ്ദേശം നടപ്പിലാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There are two commands that single-step at the machine-instruction level: stepi and nexti.","translation":"മെഷീൻ-നിർദ്ദേശ തലത്തിൽ സിംഗിൾ-സ്റ്റെപ്പ് ചെയ്യുന്ന രണ്ട് കമാൻഡുകൾ ഉണ്ട്: stepi, nexti എന്നിവയാണവ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The difference between stepi and nexti may seem odd at first.","translation":"stepi, nexti എന്നിവ തമ്മിലുള്ള വ്യത്യാസം ആദ്യ കാഴ്ചയിൽ വിചിത്രമായി തോന്നാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"While you're stepping along through a program, you may wish to avoid climbing down into subroutines.","translation":"നിങ്ങൾ ഒരു പ്രോഗ്രാമിലൂടെ കടന്നുപോകുമ്പോൾ, സബ്റൂട്ടീനുകളിലേക്ക് ഇറങ്ങുന്നത് ഒഴിവാക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can edit source code files and make files.","translation":"നിങ്ങൾക്ക് സോഴ്സ് കോഡ് ഫയലുകൾ എഡിറ്റ് ചെയ്യാനും ഫയലുകൾ ഉണ്ടാക്കാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can assemble files and link them to generate executable files.","translation":"നിങ്ങൾക്ക് ഫയലുകൾ അസംബിൾ ചെയ്യാനും എക്സിക്യൂട്ടബിൾ ഫയലുകൾ ഉണ്ടാക്കാൻ അവ ലിങ്ക് ചെയ്യാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can run the executable program files to test them.","translation":"നിങ്ങൾക്ക് എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാം ഫയലുകൾ പ്രവർത്തിപ്പിച്ച് അവ ടെസ്റ്റ് ചെയ്യാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You can invoke the GNU debugger.","translation":"നിങ്ങൾക്ക് GNU ഡീബഗ്ഗർ പ്രവർത്തിപ്പിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Why waste time ducking in and out of EMACS as though it were nothing more than a text editor?","translation":"ഒരു ടെക്സ്റ്റ് എഡിറ്റർ എന്നതിനപ്പുറം EMACS-ൽ നിന്നും പുറത്തേക്കും അകത്തേക്കും ഇറങ്ങിവരുന്നത് എന്തിന് സമയം കളയണം?","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"More than one book has been written about EMACS.","translation":"EMACS-നെക്കുറിച്ച് ഒന്നിലധികം പുസ്തകങ്ങൾ എഴുതിയിട്ടുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"I recommend the book Learning GNU EMACS by Debra Cameron, Bill Rosenblatt, and Eric S. Raymond (O'Reilly, 1996).","translation":"ഡെബ്രാ കാമറൺ, ബിൽ റോസൻബ്ലാറ്റ്, എറിക് എസ്. റെയ്മണ്ട് എന്നിവർ ചേർന്ന് എഴുതിയ Learning GNU EMACS (O'Reilly, 1996) എന്ന പുസ്തകം ഞാൻ ശുപാർശ ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"My one gripe is that it doesn't cover the X Window version of EMACS specifically, but all the key commands are the same.","translation":"എൻ്റെ ഒരു പരാതി, ഇത് EMACS-ൻ്റെ X വിൻഡോ പതിപ്പിനെക്കുറിച്ച് വ്യക്തമായി പറയുന്നില്ല, എന്നാൽ എല്ലാ കീ കമാൻഡുകളും ഒന്നുതന്നെയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The important big-picture thing to understand about EMACS is that it is buffer-based.","translation":"EMACS-നെക്കുറിച്ച് മനസ്സിലാക്കേണ്ട പ്രധാനപ്പെട്ട കാര്യം, ഇത് ബഫർ അടിസ്ഥാനമാക്കിയുള്ളതാണ് എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When you open a file, EMACS opens a buffer and loads text from the opened file into that buffer.","translation":"നിങ്ങൾ ഒരു ഫയൽ തുറക്കുമ്പോൾ, EMACS ഒരു ബഫർ തുറക്കുകയും തുറന്ന ഫയലിൽ നിന്നുള്ള ടെക്സ്റ്റ് ആ ബഫറിലേക്ക് ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can also open a buffer as a scratch buffer, type something in it, cut or copy portions of that buffer into another buffer, and then just kill the scratch buffer (delete it) without saving it to disk.","translation":"നിങ്ങൾക്ക് ഒരു സ്ക്രാച്ച് ബഫറായി ഒരു ബഫർ തുറക്കാനും, അതിൽ എന്തെങ്കിലും ടൈപ്പ് ചെയ്യാനും, ആ ബഫറിൻ്റെ ഭാഗങ്ങൾ മറ്റൊരു ബഫറിലേക്ക് കട്ട് ചെയ്യുകയോ കോപ്പി ചെയ്യുകയോ ചെയ്യാനും, തുടർന്ന് അത് ഡിസ്കിലേക്ക് സേവ് ചെയ്യാതെ തന്നെ സ്ക്രാച്ച് ബഫർ നശിപ്പിക്കാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"When EMACS runs the make facility, it pipes output from make and from the tools that make invokes into a new buffer.","translation":"EMACS make സൗകര്യം പ്രവർത്തിപ്പിക്കുമ്പോൾ, make-ൽ നിന്നും make പ്രവർത്തിപ്പിക്കുന്ന ടൂളുകളിൽ നിന്നുമുള്ള ഔട്ട്പുട്ട് ഒരു പുതിയ ബഫറിലേക്ക് നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Most usefully, you can invoke a Unix shell (I use bash) from inside EMACS, and EMACS will pipe its output into a new buffer, which like any buffer can be saved to disk.","translation":"ഏറ്റവും പ്രയോജനകരമായി, നിങ്ങൾക്ക് EMACS-ൽ നിന്ന് ഒരു Unix ഷെൽ (ഞാൻ ബാഷ് ഉപയോഗിക്കുന്നു) പ്രവർത്തിപ്പിക്കാൻ കഴിയും, കൂടാതെ EMACS അതിൻ്റെ ഔട്ട്പുട്ട് ഒരു പുതിയ ബഫറിലേക്ക് നൽകും, ഇത് ഏതൊരു ബഫറിനെയും പോലെ ഡിസ്കിൽ സേവ് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Opening a Shell from inside EMACS This last is worth explaining, because it is less obvious than most of the editing commands.","translation":"EMACS-ൽ നിന്ന് ഒരു ഷെൽ തുറക്കുന്നു: ഇത് വിശദീകരിക്കേണ്ടതാണ്, കാരണം ഇത് മിക്ക എഡിറ്റിംഗ് കമാൻഡുകളെക്കാളും വ്യക്തമല്ലാത്ത ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There is currently no EMACS menu item that opens a shell in a window.","translation":"നിലവിൽ, ഒരു വിൻഡോയിൽ ഒരു ഷെൽ തുറക്കുന്ന ഒരു EMACS മെനു ഇനമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"To open a shell, the command is \"Esc x shell.\"","translation":"ഒരു ഷെൽ തുറക്കാൻ, കമാൻഡ് ഇതാണ്: \"Esc x shell.\"","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You press the Esc key followed by the lowercase x key (don't press both at once!) and, in its command line at the bottom of its window, EMACS will display the unhelpful string \"M-x.\"","translation":"നിങ്ങൾ Esc കീ അമർത്തുക, തുടർന്ന് ചെറിയ അക്ഷരത്തിലുള്ള x കീ അമർത്തുക (രണ്ടും ഒരുമിപ്പിക്കരുത്!) കൂടാതെ വിൻഡോയുടെ താഴെയുള്ള കമാൻഡ് ലൈനിൽ, EMACS ഉപയോഗശൂന്യമായ \"M-x.\" എന്ന സ്ട്രിംഗ് പ്രദർശിപ്പിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"After the string \"M-x\" you must type \"shell\" and then press Enter.","translation":"\"M-x\" എന്ന സ്ട്രിംഗിന് ശേഷം നിങ്ങൾ \"shell\" എന്ന് ടൈപ്പ് ചെയ്യണം, തുടർന്ന് Enter അമർത്തുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"EMACS will open a new buffer in a window and will begin piping shell output from the default shell into that window.","translation":"EMACS ഒരു വിൻഡോയിൽ ഒരു പുതിയ ബഫർ തുറക്കുകയും ഡിഫോൾട്ട് ഷെല്ലിൽ നിന്നുള്ള ഷെൽ ഔട്ട്പുട്ട് ആ വിൻഡോയിലേക്ക് നൽകാൻ തുടങ്ങുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"You can invoke the executables you build with make by naming them (usually prepended by \"./\") just as you would from the shell.","translation":"നിങ്ങൾ make ഉപയോഗിച്ച് നിർമ്മിക്കുന്ന എക്സിക്യൂട്ടബിളുകൾ ഷെല്ലിൽ നിന്ന് ചെയ്യുന്നതുപോലെ അവയുടെ പേര് നൽകി (സാധാരണയായി \"./\" ചേർത്ത്) പ്രവർത്തിപ്പിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The C Library's Time Machine","translation":"സി ലൈബ്രറിയുടെ ടൈം മെഷീൻ","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"By understanding how to call these functions as assembly language procedures, you'll be able to read the current date.","translation":"അസംബ്ലി ഭാഷാ പ്രക്രിയകളായി ഈ ഫംഗ്ഷനുകൾ എങ്ങനെ വിളിക്കണമെന്ന് മനസ്സിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ഇപ്പോഴത്തെ തീയതി വായിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This value is the number of seconds that have passed in the \"Unix Epoch,\" which began on January 1, 1970, 00:00:00 universal time.","translation":"ഈ മൂല്യം \"യൂണിക്സ് യുഗം\" ത്തിൽ കടന്നുപോയ നിമിഷങ്ങളുടെ എണ്ണമാണ്, ഇത് 1970 ജനുവരി 1-ന്, 00:00:00 യൂണിവേഴ്സൽ ടൈമിലാണ് ആരംഭിച്ചത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The number is called time_t.","translation":"ഈ സംഖ്യയെ time_t എന്ന് വിളിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"A time_t value is just an arbitrary seconds count and doesn't tell you much on its own.","translation":"ഒരു time_t മൂല്യം ഏതെങ്കിലും നിമിഷങ്ങളുടെ എണ്ണമാണ്, അത് സ്വയം അധികമൊന്നും പറയുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A second standard data type implemented by the standard C library is much more useful.","translation":"സ്റ്റാൻഡേർഡ് സി ലൈബ്രറി നടപ്പിലാക്കിയ രണ്ടാമത്തെ സാധാരണ ഡാറ്റാ ടൈപ്പ് വളരെ ഉപയോഗപ്രദമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"A tm structure is a grouping of nine 32-bit values that express the current time and date.","translation":"ഒരു tm ഘടന നിലവിലെ സമയവും തീയതിയും പ്രകടിപ്പിക്കുന്ന ഒമ്പത് 32-ബിറ്റ് മൂല്യങ്ങളുടെ ഒരു ഗ്രൂപ്പിംഗാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There are C library functions that convert time_t values to tm values and back.","translation":"time_t മൂല്യങ്ങളെ tm മൂല്യങ്ങളായും തിരിച്ചും മാറ്റുന്ന സി ലൈബ്രറി ഫംഗ്ഷനുകൾ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Fetching time_t Values from the System Clock","translation":"സിസ്റ്റം ക്ലോക്കിൽ നിന്ന് time_t മൂല്യങ്ങൾ എടുക്കുന്നു","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Fetching the value for the current time is done by calling the time function.","translation":"നിലവിലെ സമയത്തിനായുള്ള മൂല്യം എടുക്കുന്നത് സമയം ഫംഗ്ഷൻ വിളിക്കുന്നതിലൂടെയാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The time function can potentially return the time value in two places.","translation":"സമയം ഫംഗ്ഷന് രണ്ട് സ്ഥലങ്ങളിൽ സമയ മൂല്യം നൽകാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Converting a time_t Value to a Formatted String","translation":"ഒരു time_t മൂല്യത്തെ ഫോർമാറ്റ് ചെയ്ത സ്ട്രിംഗിലേക്ക് മാറ്റുന്നു","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"By itself, time_t doesn't tell you a great deal.","translation":"സ്വന്തമായി, time_t നിങ്ങളോട് കൂടുതൽ വിവരങ്ങൾ പറയുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The C library contains a function that will return a pointer to a formatted string representation of a given time_t.","translation":"നൽകിയിട്ടുള്ള time_t-യുടെ ഫോർമാറ്റ് ചെയ്ത സ്ട്രിംഗ് പ്രാതിനിധ്യം നൽകുന്ന ഒരു പോയിന്റർ നൽകുന്ന ഒരു ഫംഗ്ഷൻ സി ലൈബ്രറിയിൽ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Generating Separate Local Time Values","translation":"പ്രത്യേക പ്രാദേശിക സമയ മൂല്യങ്ങൾ ഉണ്ടാക്കുന്നു","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The C library also gives you a function to break out the various components of the date and time into separate values.","translation":"തിയ്യതിയുടെയും സമയത്തിൻ്റെയും വിവിധ ഘടകങ്ങളെ പ്രത്യേക മൂല്യങ്ങളായി വേർതിരിക്കുന്ന ഒരു ഫംഗ്ഷനും സി ലൈബ്രറി നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Uninitialized Storage and [.bss]","translation":"തുടക്കമില്ലാത്ത സംഭരണവും [.bss]","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The [.data] section was intended to contain initialized data.","translation":"[.data] വിഭാഗം ആരംഭിച്ച ഡാറ്റ ഉൾക്കൊള്ളാൻ ഉദ്ദേശിച്ചുള്ളതായിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Making a Copy of clib's tm Struct with MOVSD","translation":"MOVSD ഉപയോഗിച്ച് clib-ൻ്റെ tm ഘടനയുടെ ഒരു പകർപ്പ് ഉണ്ടാക്കുന്നു","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"It's sometimes handy to be able to keep a separate copy of a tm structure, especially if you're working with several date/time values at once.","translation":"ഒരു tm ഘടനയുടെ പ്രത്യേക പകർപ്പ് സൂക്ഷിക്കുന്നത് ചിലപ്പോൾ സഹായകമാകും, പ്രത്യേകിച്ചും നിങ്ങൾ ഒന്നിലധികം തീയതി/സമയ മൂല്യങ്ങൾ ഒരേസമയം ഉപയോഗിക്കുമ്പോൾ.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Once your stack is clean, to destroy the stack frame you must first pop the caller's register values back into their registers, making sure your pops are in the correct order.","translation":"നിങ്ങളുടെ സ്റ്റാക്ക് വൃത്തിയാക്കിയ ശേഷം, സ്റ്റാക്ക് ഫ്രെയിം നശിപ്പിക്കുന്നതിന്, കോളറുടെ രജിസ്റ്റർ മൂല്യങ്ങൾ ശരിയായ ക്രമത്തിൽ പോപ്പ് ചെയ്ത്, രജിസ്റ്ററുകളിലേക്ക് തിരികെ നൽകണം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"With that done, we undo the logic we followed in creating the stack frame: We restore the caller's ESP by moving the value from EBP into ESP, and finally pop the caller's EBP value off the stack: mov esp,ebp pop ebp That's it!","translation":"അത് ചെയ്തു കഴിഞ്ഞാൽ, സ്റ്റാക്ക് ഫ്രെയിം ഉണ്ടാക്കുന്നതിൽ നമ്മൾ പിന്തുടർന്ന ലോജിക് നമ്മൾ പഴയപടിയാക്കുന്നു: EBP-യിൽ നിന്നുള്ള മൂല്യം ESP-യിലേക്ക് നീക്കി കോളറുടെ ESP പുനഃസ്ഥാപിക്കുന്നു, തുടർന്ന് കോളറുടെ EBP മൂല്യം സ്റ്റാക്കിൽ നിന്ന് പോപ്പ് ചെയ്യുന്നു: mov esp,ebp pop ebp അത്രയേയുള്ളൂ!","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The stack frame is gone, and the stack and sacred registers are now in the same state they were in when the startup code handed control to our program.","translation":"സ്റ്റാക്ക് ഫ്രെയിം പോയി, സ്റ്റാർട്ടപ്പ് കോഡ് നമ്മുടെ പ്രോഗ്രാമിന് നിയന്ത്രണം നൽകുമ്പോൾ ഉണ്ടായിരുന്ന അതേ അവസ്ഥയിലേക്ക് സ്റ്റാക്കും വിശുദ്ധ രജിസ്റ്ററുകളും ഇപ്പോൾ എത്തിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It's now safe to execute the RET instruction that sends control to the shutdown code from the C library.","translation":"C ലൈബ്രറിയിൽ നിന്നുള്ള ഷട്ട്ഡൗൺ കോഡിലേക്ക് നിയന്ത്രണം അയയ്ക്കുന്ന RET നിർദ്ദേശം ഇപ്പോൾ സുരക്ഷിതമായി നടപ്പിലാക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The file BOILER. ASM I showed earlier (it's on the CD-ROM for this book) is a boilerplate Linux assembly language program.","translation":"ഞാൻ നേരത്തെ കാണിച്ച BOILER. ASM എന്ന ഫയൽ (ഈ പുസ്തകത്തിലെ CD-ROM-ൽ ഉണ്ട്) ഒരു സാധാരണ Linux അസംബ്ലി ഭാഷാ പ്രോഗ്രാമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It has a comment header, the three sections [.text], [.data], and [.bss], and all the code necessary to create and then destroy a stack frame.","translation":"ഇതിൽ ഒരു കമന്റ് ഹെഡർ, [.text], [.data], [.bss] എന്നീ മൂന്ന് ഭാഗങ്ങളും, ഒരു സ്റ്റാക്ക് ഫ്രെയിം ഉണ്ടാക്കാനും നശിപ്പിക്കാനും ആവശ്യമായ എല്ലാ കോഡുകളും ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In between, you place the code for your own programs.","translation":"ഇവയ്ക്കിടയിൽ, നിങ്ങളുടെ സ്വന്തം പ്രോഗ്രാമുകൾക്കുള്ള കോഡ് സ്ഥാപിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"All of the programs we create in the rest of this chapter will be built on this common framework.","translation":"ഈ അധ്യായത്തിന്റെ ബാക്കി ഭാഗങ്ങളിൽ നമ്മൾ ഉണ്ടാക്കുന്ന എല്ലാ പ്രോഗ്രാമുകളും ഈ പൊതുവായ ചട്ടക്കൂടിലാണ് നിർമ്മിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"I've said plenty of times that x86 protected mode is a wonderful thing, but I've never actually come out and said what it gives you.","translation":"x86 പ്രൊട്ടക്റ്റഡ് മോഡ് ഒരു അത്ഭുതകരമായ കാര്യമാണെന്ന് ഞാൻ പലതവണ പറഞ്ഞിട്ടുണ്ട്, എന്നാൽ ഇത് നിങ്ങൾക്ക് എന്താണ് നൽകുന്നതെന്ന് ഞാൻ ഇതുവരെ പറഞ്ഞിട്ടില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In short, from the perspective of beginning assembly programmers, it comes down to more instructions, more versatile registers, a more stable and predictable environment, and no segments!","translation":"ചുരുക്കത്തിൽ, തുടക്കക്കാരായ അസംബ്ലി പ്രോഗ്രാമർമാരുടെ കാഴ്ചപ്പാടിൽ, ഇത് കൂടുതൽ നിർദ്ദേശങ്ങൾ, കൂടുതൽ വൈവിധ്യമുള്ള രജിസ്റ്ററുകൾ, കൂടുതൽ സ്ഥിരതയുള്ളതും പ്രവചിക്കാവുന്നതുമായ ഒരു അന്തരീക്ഷം, കൂടാതെ സെഗ്മെന്റുകളില്ല എന്നിവയിലേക്ക് വരുന്നു!","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"(Can you tell which part I like best?)","translation":"(ഏത് ഭാഗമാണ് എനിക്കേറ്റവും ഇഷ്ടപ്പെട്ടതെന്ന് പറയാമോ?)","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You know you're running on a 386 or more advanced Intel processor.","translation":"നിങ്ങൾ ഒരു 386 അല്ലെങ്കിൽ അതിലും മികച്ച Intel പ്രോസസ്സറിലാണ് പ്രവർത്തിക്കുന്നതെന്ന് നിങ്ങൾക്കറിയാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"There's much less to be concerned about in terms of whether you can use certain instructions as there are when you're running DOS.","translation":"DOS പ്രവർത്തിക്കുമ്പോൾ ചില നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കാൻ കഴിയുമോ എന്നതിനെക്കുറിച്ച് നിങ്ങൾ കൂടുതൽ ശ്രദ്ധിക്കേണ്ടതില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Nearly every new processor family that Intel has released has added some instructions to the x86 instruction set, but the really big gulf is between the 386 and those CPUs that came before it.","translation":"ഇന്റൽ പുറത്തിറക്കിയ മിക്കവാറും എല്ലാ പുതിയ പ്രോസസ്സർ ഫാമിലികളും x86 ഇൻസ്ട്രക്ഷൻ സെറ്റിലേക്ക് ചില നിർദ്ദേശങ്ങൾ ചേർത്തിട്ടുണ്ട്, എന്നാൽ 386-നും അതിനുമുമ്പുള്ള CPU-കൾക്കും ഇടയിലാണ് വലിയ വ്യത്യാസം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Thirty-two-bit protected mode is not present in the 8088, 8086, or 286, so whatever limitations are attached to those processors you can just forget.","translation":"8088, 8086, അല്ലെങ്കിൽ 286 എന്നിവയിൽ മുപ്പത്തിരണ്ട്-ബിറ്റ് പ്രൊട്ടക്റ്റഡ് മോഡ് ലഭ്യമല്ല, അതിനാൽ ആ പ്രോസസ്സറുകളുമായി ബന്ധപ്പെട്ട പരിമിതികളെക്കുറിച്ച് നിങ്ങൾക്ക് മറക്കാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Segments still exist in 32-bit protected mode, but as each segment can be as large as 4 GB, all the segments are basically in the same memory space, and thus factor out.","translation":"32-ബിറ്റ് പ്രൊട്ടക്റ്റഡ് മോഡിൽ സെഗ്മെന്റുകൾ ഇപ്പോഴും നിലവിലുണ്ട്, എന്നാൽ ഓരോ സെഗ്മെന്റും 4 GB വരെ വലുതാകാൻ കഴിയുന്നതിനാൽ, എല്ലാ സെഗ്മെന്റുകളും അടിസ്ഥാനപരമായി ഒരേ മെമ്മറി സ്പേസിലാണ്, അതിനാൽ അവയെ ഒഴിവാക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The 32-bit offset address can be considered the sole address for an item, and it may be contained in a single 32-bit register.","translation":"32-ബിറ്റ് ഓഫ്സെറ്റ് വിലാസത്തെ ഒരു ഇനത്തിന്റെ ഏക വിലാസമായി കണക്കാക്കാം, കൂടാതെ ഇത് ഒരു 32-ബിറ്റ് രജിസ്റ്ററിൽ ഉൾക്കൊള്ളാൻ സാധ്യതയുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This means that we need no longer be concerned about such things as segment overrides, or recalling whether a data item is addressed relative to DS or ES.","translation":"അതായത് സെഗ്മെന്റ് ഓവർറൈഡുകൾ പോലുള്ള കാര്യങ്ങളെക്കുറിച്ചോ, ഒരു ഡാറ്റാ ഇനം DS അല്ലെങ്കിൽ ES എന്നിവയുമായി ബന്ധപ്പെട്ടതാണോ എന്ന് ഓർമ്മിക്കുന്നതിനെക്കുറിച്ചോ ഇനി നമ്മൾ വിഷമിക്കേണ്ടതില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This banishes a good deal of complexity from programs, and you'll find that flat model coding is remarkably simple compared to the segment wrestling DOS programmers suffered through starting in 1981.","translation":"ഇത് പ്രോഗ്രാമുകളിൽ നിന്ന് ഒരുപാട് സങ്കീർണ്ണത ഇല്ലാതാക്കുന്നു, കൂടാതെ 1981-ൽ ആരംഭിച്ച DOS പ്രോഗ്രാമർമാർ അനുഭവിച്ച സെഗ്മെന്റ് പ്രശ്നങ്ങളെ അപേക്ഷിച്ച് ഫ്ലാറ്റ് മോഡൽ കോഡിംഗ് വളരെ ലളിതമാണെന്ന് നിങ്ങൾ കണ്ടെത്തും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"One of the more aggravating limitations of ancient Intel CPUs such as the 8086 and 8088 is that the general-purpose registers weren't exactly general.","translation":"8086, 8088 തുടങ്ങിയ പഴയകാല Intel CPU-കളുടെ ഏറ്റവും വലിയ പരിമിതികളിലൊന്ന്, പൊതു ആവശ്യത്തിനുള്ള രജിസ്റ്ററുകൾ യഥാർത്ഥത്തിൽ പൊതുവായവ ആയിരുന്നില്ല എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"They send it to a special Unix mechanism called standard output, which is a destination to which you can send text.","translation":"അവർ ഇത് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് എന്ന് വിളിക്കപ്പെടുന്ന ഒരു പ്രത്യേക Unix സംവിധാനത്തിലേക്ക് അയയ്ക്കുന്നു, അവിടെ നിങ്ങൾക്ക് ടെക്സ്റ്റ് അയയ്ക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output defaults to the screen display.","translation":"സ്ക്രീൻ ഡിസ്പ്ലേയിലേക്ക് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് സ്ഥിരസ്ഥിതിയായി വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Unless you redirect standard output to some other place (such as a disk-based text file), characters written to standard output will appear on your screen.","translation":"നിങ്ങൾ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് മറ്റേതെങ്കിലും സ്ഥലത്തേക്ക് (ഒരു ഡിസ്ക് അടിസ്ഥാനമാക്കിയുള്ള ടെക്സ്റ്റ് ഫയൽ പോലുള്ളവ) റീഡയറക്ട് ചെയ്യുന്നില്ലെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് എഴുതിയ അക്ഷരങ്ങൾ നിങ്ങളുടെ സ്ക്രീനിൽ ദൃശ്യമാകും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output is one of three standard text streams that Linux will open and make available to a running Linux application, no matter how small.","translation":"ഒരു പ്രവർത്തിക്കുന്ന Linux ആപ്ലിക്കേഷനായി Linux തുറക്കുകയും ലഭ്യമാക്കുകയും ചെയ്യുന്ന മൂന്ന് സാധാരണ ടെക്സ്റ്റ് സ്ട്രീമുകളിൽ ഒന്നാണ് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട്, അത് എത്ര ചെറുതാണെങ്കിലും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard output (stdout) which defaults to the screen display.","translation":"സ്ക്രീൻ ഡിസ്പ്ലേയിലേക്ക് സ്ഥിരസ്ഥിതിയായി വരുന്ന സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് (stdout).","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"It can be redirected to a text file or some other text-oriented device such as a printer.","translation":"ഇതിനെ ഒരു ടെക്സ്റ്റ് ഫയലിലേക്കോ പ്രിന്റർ പോലുള്ള മറ്റ് ടെക്സ്റ്റ് ഓറിയന്റഡ് ഉപകരണത്തിലേക്കോ റീഡയറക്ട് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Standard error (stderr) which also defaults to the screen display.","translation":"സ്ക്രീൻ ഡിസ്പ്ലേയിലേക്ക് സ്ഥിരസ്ഥിതിയായി വരുന്ന സ്റ്റാൻഡേർഡ് എറർ (stderr).","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The availability of this standard file allows programs to write their error messages to something other than the screen display, for debugging or logging purposes.","translation":"ഡീബഗ്ഗിംഗിനോ ലോഗിംഗിനോ വേണ്ടി, ഈ സ്റ്റാൻഡേർഡ് ഫയലിന്റെ ലഭ്യത പ്രോഗ്രാമുകളെ അവരുടെ പിശക് സന്ദേശങ്ങൾ സ്ക്രീൻ ഡിസ്പ്ലേയിൽ നിന്ന് വ്യത്യസ്തമായ ഒന്നിലേക്ക് എഴുതാൻ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Standard input (stdin) which (in contrast to stdout and stderr) is a source of text.","translation":"സ്റ്റാൻഡേർഡ് ഇൻപുട്ട് (stdin) (stdout, stderr എന്നിവയിൽ നിന്ന് വ്യത്യസ്തമായി) ടെക്സ്റ്റിന്റെ ഒരു ഉറവിടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It defaults to the system keyboard, but it can be redirected to a text file, which can allow you to drive a program with \"canned\" inputs stored in a separate file.","translation":"ഇത് സിസ്റ്റം കീബോർഡിലേക്ക് സ്ഥിരസ്ഥിതിയായി വരുന്നു, എന്നാൽ ഇതിനെ ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് റീഡയറക്ട് ചെയ്യാവുന്നതാണ്, ഇത് ഒരു പ്രത്യേക ഫയലിൽ സംഭരിച്ചിട്ടുള്ള \"canned\" ഇൻപുട്ടുകൾ ഉപയോഗിച്ച് ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ നിങ്ങളെ അനുവദിക്കും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"If your program sends text to standard output (which is what happens by default), you can redirect its output to a text file when executing the program on the Unix command line.","translation":"നിങ്ങളുടെ പ്രോഗ്രാം സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് ടെക്സ്റ്റ് അയയ്ക്കുകയാണെങ്കിൽ (സ്ഥിരസ്ഥിതിയായി സംഭവിക്കുന്നത് ഇതാണ്), Unix കമാൻഡ് ലൈനിൽ പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ അതിന്റെ ഔട്ട്പുട്ട് ഒരു ടെക്സ്റ്റ് ഫയലിലേക്ക് റീഡയറക്ട് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Here, instead of appearing on your screen, the text displayed by the EATLINUX program is sent to the text file eattext.txt instead.","translation":"ഇവിടെ, നിങ്ങളുടെ സ്ക്രീനിൽ ദൃശ്യമാകുന്നതിനുപകരം, EATLINUX പ്രോഗ്രാം പ്രദർശിപ്പിക്കുന്ന ടെക്സ്റ്റ് eattext.txt എന്ന ടെക്സ്റ്റ് ഫയലിലേക്ക് അയയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The printf routine allows you to do a number of truly useful things, all with one function call.","translation":"printf റ routine ട്ടീൻ ഒരൊറ്റ ഫംഗ്ഷൻ കോൾ ഉപയോഗിച്ച് നിരവധി ഉപയോഗപ്രദമായ കാര്യങ്ങൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Output text without a newline","translation":"ഒരു പുതിയ വരിയില്ലാതെ ടെക്സ്റ്റ് ഔട്ട്പുട്ട് ചെയ്യുക","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Convert numeric data to text in numerous formats by passing formatting codes along with the data","translation":"ഡാറ്റയ്ക്കൊപ്പം ഫോർമാറ്റിംഗ് കോഡുകൾ നൽകി നിരവധി ഫോർമാറ്റുകളിൽ സംഖ്യാ ഡാറ്റയെ ടെക്സ്റ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Output text to a stream that includes multiple strings stored separately","translation":"പ്രത്യേകമായി സംഭരിച്ചിട്ടുള്ള ഒന്നിലധികം സ്ട്രിംഗുകൾ ഉൾപ്പെടുന്ന ഒരു സ്ട്രീമിലേക്ക് ടെക്സ്റ്റ് ഔട്ട്പുട്ട് ചെയ്യുക","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The printf routine will gladly display a simple string like \"Eat at Joe's!\"-but you can merge other text strings and converted numeric data with that base string as it travels toward standard output, and show it all seamlessly together.","translation":"printf റ routine ട്ടീൻ \"Eat at Joe's!\" പോലുള്ള ലളിതമായ ഒരു സ്ട്രിംഗ് സന്തോഷത്തോടെ പ്രദർശിപ്പിക്കും - എന്നാൽ നിങ്ങൾക്ക് മറ്റ് ടെക്സ്റ്റ് സ്ട്രിംഗുകളും പരിവർത്തനം ചെയ്ത സംഖ്യാ ഡാറ്റയും ആ അടിസ്ഥാന സ്ട്രിംഗുമായി ലയിപ്പിക്കാനും ഇത് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് പോകുമ്പോൾ തടസ്സമില്ലാതെ ഒരുമിപ്പിക്കാനും കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"This is done by dropping formatting codes into the base string, and then passing a data item to printf for each of those formatting codes, along with the base string.","translation":"ഇത് ചെയ്യുന്നത് ഫോർമാറ്റിംഗ് കോഡുകൾ അടിസ്ഥാന സ്ട്രിംഗിലേക്ക് ചേർക്കുന്നതിലൂടെയും, തുടർന്ന് ആ ഫോർമാറ്റിംഗ് കോഡുകളിൽ ഒന്നിന് printf-ലേക്ക് ഒരു ഡാറ്റാ ഇനം അടിസ്ഥാന സ്ട്രിംഗിനൊപ്പം നൽകുന്നതിലൂടെയുമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A formatting code begins with a percent sign and includes information relating to the type and size of the data item being merged with the base string, as well as how that information should be presented.","translation":"ഒരു ഫോർമാറ്റിംഗ് കോഡ് ശതമാന ചിഹ്നത്തിൽ ആരംഭിച്ച്, അടിസ്ഥാന സ്ട്രിംഗുമായി ലയിപ്പിക്കുന്ന ഡാറ്റാ ഇനത്തിന്റെ തരവും വലുപ്പവും, അതുപോലെ ആ വിവരങ്ങൾ എങ്ങനെ അവതരിപ്പിക്കണം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങളും ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Let's look at a very simple example to start out.","translation":"ആരംഭിക്കുന്നതിന് വളരെ ലളിതമായ ഒരു ഉദാഹരണം നോക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The program uses the 'time' function to get the current time.","translation":"പ്രോഗ്രാം ഇപ്പോഴത്തെ സമയം അറിയാൻ 'സമയം' ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The 'srand' function is seeded with the time value.","translation":"'srand' ഫംഗ്ഷൻ സമയ മൂല്യം ഉപയോഗിച്ച് സീഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The code demonstrates how to generate pseudorandom numbers.","translation":"കൃത്രിമ യാദൃശ്ചിക സംഖ്യകൾ എങ്ങനെ ഉണ്ടാക്കാമെന്ന് കോഡ് കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The 'rand' function is used to get the next number in the sequence.","translation":"അടുത്ത സംഖ്യ ലഭിക്കാൻ 'rand' ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The program is written in assembly language.","translation":"പ്രോഗ്രാം അസംബ്ലി ഭാഷയിലാണ് എഴുതിയിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The example shows how to seed the random number generator.","translation":"റാൻഡം നമ്പർ ജനറേറ്റർ എങ്ങനെ സീഡ് ചെയ്യാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The code uses the NASM assembler.","translation":"കോഡ് NASM അസംബ്ലർ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The program displays an array of random numbers.","translation":"പ്രോഗ്രാം ക്രമരഹിതമായ സംഖ്യകളുടെ ഒരു ശ്രേണി പ്രദർശിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The example demonstrates the use of 'printf' and 'puts' functions.","translation":"'printf', 'puts' എന്നീ ഫംഗ്ഷനുകളുടെ ഉപയോഗം ഈ ഉദാഹരണം വ്യക്തമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The code includes subroutines for generating random numbers of different sizes.","translation":"വിവിധ വലുപ്പത്തിലുള്ള ക്രമരഹിത സംഖ്യകൾ ഉണ്ടാക്കുന്നതിനുള്ള ഉപവിഭാഗങ്ങൾ കോഡിൽ ഉൾപ്പെടുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The program uses local labels for better code organization.","translation":"മെച്ചപ്പെട്ട കോഡ് ഓർഗനൈസേഷനായി പ്രോഗ്രാം പ്രാദേശിക ലേബലുകൾ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The example shows how to call addresses in registers.","translation":"രജിസ്റ്ററുകളിലെ വിലാസങ്ങൾ എങ്ങനെ വിളിക്കാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The code uses a character table to generate alphanumeric characters.","translation":"അക്ഷര-അക്ക സ്വഭാവങ്ങൾ ഉണ്ടാക്കാൻ കോഡ് ഒരു പ്രതീക പട്ടിക ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The program demonstrates how to shift the random value.","translation":"ക്രമരഹിതമായ മൂല്യം എങ്ങനെ മാറ്റാമെന്ന് പ്രോഗ്രാം കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The example explains the concept of local labels.","translation":"പ്രാദേശിക ലേബലുകളുടെ ആശയം ഈ ഉദാഹരണം വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The code uses the 'shr' instruction for bit shifting.","translation":"ബിറ്റ് ഷിഫ്റ്റിംഗിനായി കോഡ് 'shr' നിർദ്ദേശം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The program is designed to be built using NASM and GCC.","translation":"NASM, GCC എന്നിവ ഉപയോഗിച്ച് നിർമ്മിക്കുന്ന രീതിയിലാണ് പ്രോഗ്രാം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The example shows how to create a string of random alphanumeric characters.","translation":"ക്രമരഹിതമായ അക്ഷര-അക്ക സ്വഭാവങ്ങളുടെ ഒരു സ്ട്രിംഗ് എങ്ങനെ ഉണ്ടാക്കാമെന്ന് ഈ ഉദാഹരണം കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The code uses the stack for saving and restoring register values.","translation":"രജിസ്റ്റർ മൂല്യങ്ങൾ സംരക്ഷിക്കാനും പുനഃസ്ഥാപിക്കാനും കോഡ് സ്റ്റാക്ക് ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The program's structure is explained in detail.","translation":"പ്രോഗ്രാമിന്റെ ഘടന വിശദമായി വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"NASM won't warn you if there is a local label with the same name on your side of a global label.","translation":"ഒരു ഗ്ലോബൽ ലേബലിന്റെ ഒരു വശത്ത് അതേ പേരുള്ള ഒരു പ്രാദേശിക ലേബൽ ഉണ്ടെങ്കിൽ NASM നിങ്ങളെ അറിയിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Bugs like this can be insanely difficult to find sometimes.","translation":"ഇതുപോലുള്ള ബഗുകൾ ചിലപ്പോൾ കണ്ടെത്താൻ വളരെ ബുദ്ധിമുട്ടാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It's possible to define data within a subroutine using NASM's pseudoinstructions including DB, DW, and DD.","translation":"DB, DW, DD എന്നിവയുൾപ്പെടെ NASM-ന്റെ സൂഡോ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ഒരു സബ്റൂട്ടീനുള്ളിൽ ഡാറ്റ നിർവചിക്കാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The subroutine allows you to issue some number of newline characters to standard output.","translation":"സബ്റൂട്ടീൻ നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് കുറച്ച് ന്യൂലൈൻ പ്രതീകങ്ങൾ നൽകാൻ അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you pass printf the address of the beginning of the string, printf will output all 10 newlines.","translation":"നിങ്ങൾ printf-ലേക്ക് സ്ട്രിംഗിന്റെ തുടക്കത്തിലെ വിലാസം നൽകുകയാണെങ്കിൽ, printf എല്ലാ 10 ന്യൂലൈനുകളും ഔട്ട്പുട്ട് ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The algorithm: To output x newline(s), we need to skip past 10 − x newline(s).","translation":"അൽഗോരിതം: x ന്യൂലൈൻ(കൾ) ഔട്ട്പുട്ട് ചെയ്യുന്നതിന്, നമ്മൾ 10 − x ന്യൂലൈൻ(കൾ) കടന്നുപോകേണ്ടതുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Having the data right in the subroutine means that it's easy to cut and paste the subroutine from one program into another.","translation":"സബ്റൂട്ടീനിൽ തന്നെ ഡാറ്റ ഉണ്ടാകുന്നത് ഒരു പ്രോഗ്രാമിൽ നിന്ന് മറ്റൊന്നിലേക്ക് സബ്റൂട്ടീൻ എളുപ്പത്തിൽ മുറിക്കാനും ഒട്ടിക്കാനും സഹായിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One of the most useful things to be able to do when writing simple utilities is to pass them parameters on the command line.","translation":"ലളിതമായ യൂട്ടിലിറ്റികൾ എഴുതുമ്പോൾ ചെയ്യാൻ കഴിയുന്ന ഏറ്റവും ഉപയോഗപ്രദമായ ഒന്നാണ് കമാൻഡ് ലൈനിൽ അവയിലേക്ക് പാരാമീറ്ററുകൾ കൈമാറുക എന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"In assembly, there's no such convenience.","translation":"അസംബ്ലിയിൽ, അത്തരം സൗകര്യങ്ങളൊന്നുമില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You have to know where and how they're stored, which is (alas) nontrivial.","translation":"അവ എവിടെ, എങ്ങനെയാണ് സംഭരിച്ചിരിക്കുന്നത് എന്ന് നിങ്ങൾ അറിയണം, ഇത് (കഷ്ടമാണ്) നിസ്സാരമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"On the other hand, getting at command-line arguments is a wonderful exercise both in the use of pointers and also of accessing the stack up-memory from EBP.","translation":"മറുവശത്ത്, കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ നേടുന്നത് പോയിന്ററുകളുടെ ഉപയോഗത്തിലും EBP-യിൽ നിന്ന് സ്റ്റാക്ക് അപ്പ്-മെമ്മറി ആക്സസ് ചെയ്യുന്നതിലും ഒരു അത്ഭുതകരമായ പരിശീലനമാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Figure 13.3 shows the pointer relationships and stack structures we have to understand to identify and read the command-line arguments.","translation":"കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ തിരിച്ചറിയാനും വായിക്കാനും നമ്മൾ മനസ്സിലാക്കേണ്ട പോയിന്റർ ബന്ധങ്ങളും സ്റ്റാക്ക് ഘടനകളും ചിത്രം 13.3-ൽ കാണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One of the things the startup code does is set up your program's access to the command-line arguments.","translation":"ആരംഭ കോഡ് ചെയ്യുന്ന ഒരു കാര്യം നിങ്ങളുടെ പ്രോഗ്രാമിന്റെ കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകളിലേക്കുള്ള ആക്സസ് സജ്ജീകരിക്കുക എന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Immediately above EBP is the return address for your portion of the code.","translation":"EBP-യുടെ തൊട്ടു മുകളിലാണ് നിങ്ങളുടെ കോഡിന്റെ റിട്ടേൺ വിലാസം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Immediately above the return address, at offset 8 from EBP (as the literature would say, at EBP+8) is an integer count of the number of arguments.","translation":"EBP-യിൽ നിന്ന് 8 ഓഫ്സെറ്റിൽ (സാഹിത്യത്തിൽ പറയുന്നതുപോലെ, EBP+8-ൽ) ആർഗ്യുമെന്റുകളുടെ എണ്ണത്തിന്റെ ഒരു പൂർണ്ണസംഖ്യാ എണ്ണം ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Reading environment variable pairs is done pretty much the same way as reading command-line arguments.","translation":"പരിസ്ഥിതി വേരിയബിൾ ജോഡികൾ വായിക്കുന്നത് കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റുകൾ വായിക്കുന്നതിന് സമാനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"EBP is your anchor point in the stack.","translation":"EBP നിങ്ങളുടെ സ്റ്റാക്കിലെ ആങ്കർ പോയിന്റാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The stack is just memory, after all, and can be addressed through registers just as any area of memory can.","translation":"എല്ലാത്തിനുമുപരി, സ്റ്റാക്ക് മെമ്മറിയാണ്, കൂടാതെ ഏതൊരു മെമ്മറി ഏരിയയും പോലെ രജിസ്റ്ററുകളിലൂടെ ഇത് അഭിസംബോധന ചെയ്യാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"With the pointer to the argument table in EBX, you now have a pointer to the first element in the argument table.","translation":"EBX-ലെ ആർഗ്യുമെന്റ് ടേബിളിലേക്കുള്ള പോയിന്റർ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ഇപ്പോൾ ആർഗ്യുമെന്റ് ടേബിളിലെ ആദ്യ ഘടകത്തിലേക്ക് ഒരു പോയിന്റർ ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Scaled addressing is the best way to do it.","translation":"സ്കെയിൽഡ് വിലാസം നൽകുന്നത് ഇത് ചെയ്യുന്നതിനുള്ള ഏറ്റവും നല്ല മാർഗ്ഗമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This message appears only if the file HELPTEXTFILE.TXT cannot be opened.","translation":"HELPTEXTFILE.TXT എന്ന ഫയൽ തുറക്കാൻ കഴിയുന്നില്ലെങ്കിൽ മാത്രമേ ഈ സന്ദേശം ദൃശ്യമാകൂ.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"You never really learn assembly language.","translation":"അസംബ്ലി ഭാഷ നിങ്ങൾ ശരിക്കും പഠിക്കുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The journey is the goal.","translation":"യാത്രയാണ് ലക്ഷ്യം.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"I got out of school in recession year 1974 with a B. A. in English.","translation":"1974-ൽ സാമ്പത്തിക മാന്ദ്യ വർഷത്തിൽ ഞാൻ ഇംഗ്ലീഷിൽ ബിരുദവുമായി സ്കൂൾ വിട്ടു.","target_lang":"ml","domain":"general","complexity":"moderate"} | |
| {"en":"I was terrified of never learning what all the little cams did.","translation":"ചെറിയ കാമുകൾ എന്താണ് ചെയ്തതെന്ന് ഒരിക്കലും പഠിക്കാത്തതിൽ ഞാൻ ഭയന്നുപോയിരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"That's how you conquer complexity.","translation":"അങ്ങനെയാണ് നിങ്ങൾ സങ്കീർണ്ണതയെ കീഴടക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The real goal was to conquer your fear of the complexity of the subject.","translation":"വിഷയത്തിന്റെ സങ്കീർണ്ണതയെക്കുറിച്ചുള്ള നിങ്ങളുടെ ഭയം ഇല്ലാതാക്കുക എന്നതായിരുന്നു യഥാർത്ഥ ലക്ഷ്യം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"What's next?","translation":"ഇനി എന്താണ്?","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"There has never been an x86 assembly language book focusing on Linux, as best I know.","translation":"എനിക്ക് അറിയാവുന്നിടത്തോളം, Linux-ൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്ന ഒരു x86 അസംബ്ലി ഭാഷാ പുസ്തകം ഇതുവരെ ഉണ്ടായിട്ടില്ല.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Mastering Turbo Assembler is a natural next step.","translation":"മാസ്റ്ററിംഗ് ടർബോ അസംബ്ലർ ഒരു സ്വാഭാവിക അടുത്ത ഘട്ടമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is the only good book on debugging ever published.","translation":"ഡീബഗ്ഗിംഗിനെക്കുറിച്ച് പ്രസിദ്ധീകരിക്കപ്പെട്ട നല്ല പുസ്തകങ്ങളിൽ ഒന്നാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is not a tutorial but a reference on Intel's x86 processors.","translation":"ഇതൊരു ട്യൂട്ടോറിയൽ അല്ല, ഇന്റലിന്റെ x86 പ്രോസസ്സറുകളെക്കുറിച്ചുള്ള ഒരു റഫറൻസാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This is a huge book covering code optimization.","translation":"കോഡ് ഒപ്റ്റിമൈസേഷൻ ഉൾക്കൊള്ളുന്ന ഒരു വലിയ പുസ്തകമാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Keep programming.","translation":"പ്രോഗ്രാമിംഗ് തുടരുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Set yourself a real challenge.","translation":"നിങ്ങൾക്കായി ഒരു യഥാർത്ഥ വെല്ലുവിളി കണ്ടെത്തുക.","target_lang":"ml","domain":"general","complexity":"simple"} | |
| {"en":"The essence of stepping away from Square One.","translation":"സ്ക്വയർ വണ്ണിൽ നിന്ന് അകന്നുപോവുക എന്നതാണ് ഇതിന്റെ കാതൽ.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When an instruction takes two operands, the destination operand is the one on the left.","translation":"ഒരു നിർദ്ദേശത്തിന് രണ്ട് ഓപ്പറാൻഡുകൾ എടുക്കുമ്പോൾ, ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡ് ഇടത് ഭാഗത്തുള്ള ഒന്നാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Each instruction contains a flag summary.","translation":"ഓരോ നിർദ്ദേശത്തിലും ഒരു ഫ്ലാഗ് സംഗ്രഹം അടങ്ങിയിരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Set if the result is too large to fit in the destination operand.","translation":"ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡിൽ ഉൾക്കൊള്ളാൻ കഴിയാത്തത്ര വലുതാണ് ഫലം എങ്കിൽ ഇത് സജ്ജമാക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"AAA makes an addition come out right in AL when what you're adding are BCD values.","translation":"നിങ്ങൾ കൂട്ടിച്ചേർക്കുന്നത് BCD മൂല്യങ്ങൾ ആകുമ്പോൾ, AAA, AL-ൽ ശരിയായ രീതിയിൽ കൂട്ടിച്ചേർക്കാൻ സഹായിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"When subroutine diskhelp is called, the caller passes a pointer to the name of the help file to be read in EBX.","translation":"diskhelp എന്ന ഉപവിധി വിളിക്കുമ്പോൾ, സഹായ ഫയലിൻ്റെ പേരിൻ്റെ ഒരു പോയിൻ്റർ EBX-ൽ വായിക്കാൻ വേണ്ടി കോളർ കൈമാറുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The file is first opened.","translation":"ആദ്യം ഫയൽ തുറക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If the attempt to open the help file fails, a very short \"fail safe\" help message is displayed from strings stored in the [.data] section of the program.","translation":"സഹായ ഫയൽ തുറക്കാൻ ശ്രമിക്കുമ്പോൾ പരാജയപ്പെട്ടാൽ, പ്രോഗ്രാമിന്റെ [.data] വിഭാഗത്തിൽ സംഭരിച്ചിട്ടുള്ള സ്ട്രിംഗുകളിൽ നിന്ന് വളരെ ചെറിയ ഒരു “പരാജയ സുരക്ഷിത” സഹായ സന്ദേശം പ്രദർശിപ്പിക്കും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Never leave the user staring at a mute cursor, wondering what's going on!","translation":"എന്താണ് സംഭവിക്കുന്നതെന്ന് അറിയാതെ, നിശബ്ദമായ ഒരു കേർസറിനെ നോക്കി ഉപയോക്താവിനെ ഒരിക്കലും തനിച്ചാക്കരുത്!","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Once the help file is opened, we start looping through a sequence that reads text lines from the opened file with fgets, and then writes those lines to standard output with printf.","translation":"സഹായ ഫയൽ തുറന്ന ശേഷം, fgets ഉപയോഗിച്ച് തുറന്ന ഫയലിൽ നിന്ന് ടെക്സ്റ്റ് ലൈനുകൾ വായിക്കുകയും തുടർന്ന് printf ഉപയോഗിച്ച് ആ വരികൾ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് എഴുതുകയും ചെയ്യുന്ന ഒരു ശ്രേണിയിലൂടെ നമ്മൾ ലൂപ്പ് ചെയ്യാൻ തുടങ്ങും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The maximum length of the lines to be read is defined by the equate HELPLEN.","translation":"വായിക്കേണ്ട വരികളുടെ പരമാവധി നീളം HELPLEN എന്ന സമവാക്യം നിർവചിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Pushing an equate value on the stack is no different from pushing an immediate value, and that's how the instruction is encoded.","translation":"ഒരു സമവാക്യ മൂല്യം സ്റ്റാക്കിലേക്ക് തള്ളുന്നത് ഒരു തൽക്ഷണ മൂല്യം തള്ളുന്നതിൽ നിന്ന് വ്യത്യസ്തമല്ല, അതാണ് നിർദ്ദേശം എൻകോഡ് ചെയ്യുന്നത്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Equates are good. Use them whenever you can.","translation":"സമവാക്യങ്ങൾ നല്ലതാണ്. കഴിയുന്നത്ര ഉപയോഗിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Each time a line is read from the file, the address of the line is pushed onto the stack and displayed with printf.","translation":"ഓരോ വരിയും ഫയലിൽ നിന്ന് വായിക്കുമ്പോഴും, വരിയുടെ വിലാസം സ്റ്റാക്കിലേക്ക് തള്ളുകയും printf ഉപയോഗിച്ച് പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"When no more lines are available to be read in the help file, fgets returns a 0 in EAX, and the program branches to the function call that closes the file.","translation":"സഹായ ഫയലിൽ ഇനി വായിക്കാൻ ലൈനുകളില്ലെങ്കിൽ, fgets EAX-ൽ 0 നൽകുന്നു, കൂടാതെ ഫയൽ അടയ്ക്കുന്ന ഫംഗ്ഷൻ കോളിലേക്ക് പ്രോഗ്രാം ബ്രാഞ്ച് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Note the fclose function, which is quite simple: You push the file handle of the open file onto the stack, and call fclose.","translation":"വളരെ ലളിതമായ fclose ഫംഗ്ഷൻ ശ്രദ്ധിക്കുക: തുറന്ന ഫയലിൻ്റെ ഫയൽ ഹാൻഡിൽ സ്റ്റാക്കിലേക്ക് തള്ളുക, തുടർന്ന് fclose എന്ന് വിളിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"That's all it takes to close a file!","translation":"ഒരു ഫയൽ അടയ്ക്കാൻ ഇത്രയും മതി!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The C library provides a function that writes the very same formatted text to any opened text file.","translation":"ഏത് തുറന്ന ടെക്സ്റ്റ് ഫയലിലേക്കും അതേ ഫോർമാറ്റിലുള്ള ടെക്സ്റ്റ് എഴുതുന്ന ഒരു ഫംഗ്ഷൻ C ലൈബ്രറി നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The fprintf function does exactly what printf does, but it takes one additional parameter on the stack: the file handle of an opened text file.","translation":"fprintf ഫംഗ്ഷൻ printf ചെയ്യുന്നത് കൃത്യമായി ചെയ്യുന്നു, എന്നാൽ ഇത് സ്റ്റാക്കിൽ ഒരു അധിക പാരാമീറ്റർ എടുക്കുന്നു: തുറന്ന ടെക്സ്റ്റ് ഫയലിൻ്റെ ഫയൽ ഹാൻഡിൽ.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"So I won't bother reexplaining how to format text for printf using formatting codes and base strings.","translation":"അതിനാൽ ഫോർമാറ്റിംഗ് കോഡുകളും അടിസ്ഥാന സ്ട്രിംഗുകളും ഉപയോഗിച്ച് printf-നായി ടെക്സ്റ്റ് എങ്ങനെ ഫോർമാറ്റ് ചെയ്യാമെന്ന് ഞാൻ വീണ്ടും വിശദീകരിക്കുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"First push any values or pointers to values (as appropriate) onto the stack.","translation":"ആദ്യം, ഏതെങ്കിലും മൂല്യങ്ങളോ മൂല്യങ്ങളിലേക്കുള്ള പോയിന്ററുകളോ (അനുയോജ്യമായ രീതിയിൽ) സ്റ്റാക്കിലേക്ക് തള്ളുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Next push the base string containing the formatting codes.","translation":"അടുത്തതായി, ഫോർമാറ്റിംഗ് കോഡുകൾ അടങ്ങിയ അടിസ്ഥാന സ്ട്രിംഗ് തള്ളുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Finally (and here's where fprintf differs from printf), push the file handle of the file to which the text should be written.","translation":"അവസാനമായി (ഇവിടെയാണ് fprintf, printf-ൽ നിന്ന് വ്യത്യസ്തമാകുന്നത്), ടെക്സ്റ്റ് എഴുതേണ്ട ഫയലിൻ്റെ ഫയൽ ഹാൻഡിൽ തള്ളുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Your text will be written to the open file.","translation":"നിങ്ങളുടെ ടെക്സ്റ്റ് തുറന്ന ഫയലിലേക്ക് എഴുതപ്പെടും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Note that to use fprintf, the destination file must have been opened for either writing or appending.","translation":"fprintf ഉപയോഗിക്കുന്നതിന്, ലക്ഷ്യസ്ഥാന ഫയൽ എഴുതുന്നതിനോ കൂട്ടിച്ചേർക്കുന്നതിനോ തുറന്നിരിക്കണം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"CALL transfers control to a procedure address.","translation":"CALL ഒരു നടപടിക്രമ വിലാസത്തിലേക്ക് നിയന്ത്രണം മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Before transferring control, CALL pushes the address of the instruction immediately after itself onto the stack.","translation":"നിയന്ത്രണം കൈമാറുന്നതിന് മുമ്പ്, CALL-ൻ്റെ തൊട്ടുപിന്നാലെയുള്ള നിർദ്ദേശത്തിന്റെ വിലാസം സ്റ്റാക്കിലേക്ക് തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This allows a RET instruction to pop the return address into either CS:IP or IP only.","translation":"RET നിർദ്ദേശത്തിന് CS:IP അല്ലെങ്കിൽ IP-യിലേക്ക് റിട്ടേൺ വിലാസം പോപ്പ് ചെയ്യാൻ ഇത് അനുവദിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"In addition to the obvious CALL to a defined label, CALL can transfer control to a Near address within a 16-bit general-purpose register.","translation":"നിർവചിക്കപ്പെട്ട ലേബലിലേക്കുള്ള വ്യക്തമായ CALL-നു പുറമെ, ഒരു 16-ബിറ്റ് പൊതു-ആവശ്യ രജിസ്റ്ററിനുള്ളിലെ ഒരു Near വിലാസത്തിലേക്ക് CALL-ന് നിയന്ത്രണം കൈമാറാൻ കഴിയും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"CALL m16 and CALL m32 are useful for creating jump tables of procedure addresses.","translation":"നടപടിക്രമ വിലാസങ്ങളുടെ ജമ്പ് ടേബിളുകൾ ഉണ്ടാക്കാൻ CALL m16, CALL m32 എന്നിവ ഉപയോഗപ്രദമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"CLC simply sets the Carry flag (CF) to the cleared (0) state.","translation":"CLC ലളിതമായി കാരി ഫ്ലാഗ് (CF) ക്ലിയർ ചെയ്ത (0) അവസ്ഥയിലേക്ക് സജ്ജമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Use CLC in situations where the Carry flag must be in a known cleared state before work begins.","translation":"ജോലി ആരംഭിക്കുന്നതിന് മുമ്പ് കാരി ഫ്ലാഗ് ഒരു അറിയപ്പെടുന്ന ക്ലിയർ ചെയ്ത അവസ്ഥയിൽ ആയിരിക്കേണ്ട സാഹചര്യങ്ങളിൽ CLC ഉപയോഗിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"CLD simply sets the Direction flag (DF) to the cleared (0) state.","translation":"CLD ലളിതമായി ഡയറക്ഷൻ ഫ്ലാഗ് (DF) ക്ലിയർ ചെയ്ത (0) അവസ്ഥയിലേക്ക് സജ്ജമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This affects the adjustment performed by repeated string instructions such as STOS, SCAS, and MOVS.","translation":"STOS, SCAS, MOVS തുടങ്ങിയ ആവർത്തിച്ചുള്ള സ്ട്രിംഗ് നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നതിനെ ഇത് ബാധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Typically, when DF = 0, the destination pointer is increased, and decreased when DF = 1.","translation":"സാധാരണയായി, DF = 0 ആകുമ്പോൾ, ലക്ഷ്യസ്ഥാന പോയിന്റർ വർദ്ധിപ്പിക്കുന്നു, DF = 1 ആകുമ്പോൾ കുറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"CMP compares its two operations, and sets the flags to indicate the results of the comparison.","translation":"CMP അതിൻ്റെ രണ്ട് പ്രവർത്തനങ്ങളെ താരതമ്യം ചെയ്യുകയും താരതമ്യത്തിന്റെ ഫലങ്ങൾ സൂചിപ്പിക്കുന്നതിന് ഫ്ലാഗുകൾ സജ്ജീകരിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The destination operand is not affected.","translation":"ലക്ഷ്യസ്ഥാന ഓപ്പറാൻ്റിനെ ഇത് ബാധിക്കില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Typically CMP is followed by one of the conditional jump instructions.","translation":"സാധാരണയായി CMP-ക്ക് ശേഷം ഏതെങ്കിലും വ്യവസ്ഥാപരമായ ജമ്പ് നിർദ്ദേശങ്ങൾ വരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"DEC decrements the operand.","translation":"DEC ഓപ്പറാൻ്റിനെ കുറയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Remember that segment registers cannot be decremented with DEC.","translation":"സെഗ്മെൻ്റ് രജിസ്റ്ററുകൾ DEC ഉപയോഗിച്ച് കുറയ്ക്കാൻ കഴിയില്ലെന്ന് ഓർമ്മിക്കുക.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If you can decrement an entire register of which only the lower half contains data, use the 16-bit opcode and save a byte.","translation":"ഡാറ്റ അടങ്ങിയിട്ടുള്ള ഒരു മുഴുവൻ രജിസ്റ്ററും നിങ്ങൾക്ക് കുറയ്ക്കാൻ കഴിയുമെങ്കിൽ, 16-ബിറ്റ് ഓപ്കോഡ് ഉപയോഗിക്കുക, ഒരു ബൈറ്റ് ലാഭിക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"IMUL multiplies its operand by AL, AX, or EAX.","translation":"IMUL അതിൻ്റെ ഓപ്പറാൻ്റിനെ AL, AX, അല്ലെങ്കിൽ EAX എന്നിവ ഉപയോഗിച്ച് ഗുണിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In both the two- and three-operand forms, the product replaces the contents of the first operand.","translation":"രണ്ട്, മൂന്ന് ഓപ്പറാൻ്റ് ഫോമുകളിൽ, ഉൽപ്പന്നം ആദ്യത്തെ ഓപ്പറാൻ്റിൻ്റെ ഉള്ളടക്കം മാറ്റിസ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"INC increments the operand.","translation":"INC ഓപ്പറാൻ്റിനെ വർദ്ധിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"INT triggers a software interrupt to one of 256 vectors in the first 1,024 bytes of memory.","translation":"INT മെമ്മറിയുടെ ആദ്യ 1,024 ബൈറ്റുകളിലെ 256 വെക്റ്ററുകളിലൊന്നിലേക്ക് ഒരു സോഫ്റ്റ്വെയർ തടസ്സം ഉണ്ടാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"LEA derives the offset of the source operand from the start of its segment and loads that offset into the destination operand.","translation":"LEA, സോഴ്സ് ഓപ്പറാൻഡിൻ്റെ ഓഫ്സെറ്റ് അതിന്റെ സെഗ്മെൻ്റിൻ്റെ തുടക്കത്തിൽ നിന്ന് എടുത്ത് ഡെസ്റ്റിനേഷൻ ഓപ്പറാൻഡിലേക്ക് ലോഡ് ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The destination operand must be a register and cannot be memory.","translation":"ഡെസ്റ്റിനേഷൻ ഓപ്പറാൻഡ് ഒരു രജിസ്റ്റർ ആയിരിക്കണം, മെമ്മറിയായിരിക്കാൻ പാടില്ല.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The source operand must be a memory operand, but it can be any size.","translation":"സോഴ്സ് ഓപ്പറാൻഡ് ഒരു മെമ്മറി ഓപ്പറാൻഡ് ആയിരിക്കണം, പക്ഷേ ഏത് വലുപ്പത്തിലും ആകാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This is a good, clean way to place the address of a variable into a register.","translation":"ഒരു വേരിയബിളിൻ്റെ വിലാസം ഒരു രജിസ്റ്ററിലേക്ക് നൽകാനുള്ള നല്ലതും വ്യക്തവുമായ വഴിയാണിത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"LEA can also be used to perform register math.","translation":"രജിസ്റ്റർ ഗണിതം ചെയ്യുന്നതിനും LEA ഉപയോഗിക്കാം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Any math that can be expressed as a valid address calculation may be done with LEA.","translation":"ഒരു സാധുവായ വിലാസ കണക്കുകൂട്ടലായി പ്രകടിപ്പിക്കാൻ കഴിയുന്ന ഏത് ഗണിതവും LEA ഉപയോഗിച്ച് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"LOOP is a combination decrement counter, test, and jump instruction.","translation":"LOOP എന്നത് ഡിക്രിമെൻ്റ് കൗണ്ടർ, ടെസ്റ്റ്, ജമ്പ് എന്നിവയുടെ സംയോജനമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"It uses the CX register in 16-bit modes, and ECX in 32-bit modes.","translation":"ഇത് 16-ബിറ്റ് മോഡുകളിൽ CX രജിസ്റ്ററും 32-ബിറ്റ് മോഡുകളിൽ ECX ഉം ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"LOOP simplifies code by acting as a DEC CX instruction, a CMP CX,0 instruction, and JZ instruction, all at once.","translation":"DEC CX ഇൻസ്ട്രക്ഷൻ, CMP CX,0 ഇൻസ്ട്രക്ഷൻ, JZ ഇൻസ്ട്രക്ഷൻ എന്നിവ ഒരേ സമയം പ്രവർത്തിക്കുന്നതിലൂടെ LOOP കോഡിനെ ലളിതമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"A repeat count must be initially loaded into CX.","translation":"ആവർത്തന എണ്ണം തുടക്കത്തിൽ CX-ലേക്ക് ലോഡ് ചെയ്യണം.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When the LOOP instruction is executed, it first decrements CX.","translation":"LOOP ഇൻസ്ട്രക്ഷൻ നടപ്പിലാക്കുമ്പോൾ, അത് ആദ്യം CX കുറയ്ക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Then it tests to see if CX = 0.","translation":"തുടർന്ന് CX = 0 ആണോ എന്ന് പരിശോധിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If CX is not 0, LOOP transfers control to the displacement specified as its operand.","translation":"CX പൂജ്യമല്ലെങ്കിൽ, LOOP അതിന്റെ ഓപ്പറാൻഡായി വ്യക്തമാക്കിയ സ്ഥാനത്തേക്ക് നിയന്ത്രണം കൈമാറും.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Here, the two procedure CALLs will be made 17 times.","translation":"ഇവിടെ, രണ്ട് പ്രൊസീജ്യർ CALL-കളും 17 തവണ ഉണ്ടാക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"LOOP does not alter any flags, even when CX is decremented to 0.","translation":"CX 0 ആയി കുറച്ചാലും LOOP ഒരു ഫ്ലാഗും മാറ്റില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Watch your initial conditions!","translation":"തുടക്കത്തിലുള്ള നിങ്ങളുടെ അവസ്ഥ ശ്രദ്ധിക്കുക!","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"If CX is initially 0, LOOP will decrement it to 65,535 (0FFFFH) and then perform the loop 65,535 times.","translation":"ആരംഭത്തിൽ CX 0 ആണെങ്കിൽ, LOOP അത് 65,535 (0FFFFH) ആയി കുറയ്ക്കുകയും തുടർന്ന് 65,535 തവണ ലൂപ്പ് പ്രവർത്തിപ്പിക്കുകയും ചെയ്യും.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"LOOPNZ and LOOPNE are synonyms and generate identical opcodes.","translation":"LOOPNZ, LOOPNE എന്നിവ പര്യായപദങ്ങളാണ്, കൂടാതെ സമാനമായ ഓപ്കോഡുകൾ ഉണ്ടാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Like LOOP, they use either CX or ECX depending on the BITS setting and hence the mode.","translation":"LOOP-യെപ്പോലെ, BITS ക്രമീകരണത്തെയും അതുപോലെ മോഡിനെയും ആശ്രയിച്ച് അവ CX അല്ലെങ്കിൽ ECX ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Think of it as \"Loop While Not Zero Flag.\"","translation":"ഇതിനെ ","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"PUSHA pushes all 16-bit general-purpose registers onto the stack.","translation":"PUSHA എല്ലാ 16-ബിറ്റ് ജനറൽ-പർപ്പസ് രജിസ്റ്ററുകളും സ്റ്റാക്കിലേക്ക് തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This instruction is present on the 286 and later CPUs and is not available in the 8086/8088.","translation":"ഈ നിർദ്ദേശം 286-ലും അതിനുശേഷമുള്ള CPU-കളിലും ഉണ്ട്, 8086/8088-ൽ ലഭ്യമല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The registers are pushed in this order: AX, CX, DX, BX, SP, BP, SI, DI","translation":"രജിസ്റ്ററുകൾ ഈ ക്രമത്തിലാണ് തള്ളുന്നത്: AX, CX, DX, BX, SP, BP, SI, DI","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In the course of executing PUSHA, the stack pointer is decremented by 16 bytes.","translation":"PUSHA നടപ്പിലാക്കുമ്പോൾ, സ്റ്റാക്ക് പോയിന്റർ 16 ബൈറ്റുകൾ കുറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHAD pushes all 32-bit general-purpose registers onto the stack.","translation":"PUSHAD എല്ലാ 32-ബിറ്റ് ജനറൽ-പർപ്പസ് രജിസ്റ്ററുകളും സ്റ്റാക്കിലേക്ക് തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This instruction is present on the 386 and later CPUs.","translation":"ഈ നിർദ്ദേശം 386-ലും അതിനുശേഷമുള്ള CPU-കളിലും ഉണ്ട്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The registers are pushed in this order: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI","translation":"രജിസ്റ്ററുകൾ ഈ ക്രമത്തിലാണ് തള്ളുന്നത്: EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The EFlags register is not pushed onto the stack by PUSHAD.","translation":"EFlags രജിസ്റ്റർ PUSHAD ഉപയോഗിച്ച് സ്റ്റാക്കിലേക്ക് തള്ളുന്നില്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHF simply pushes the current contents of the Flags register onto the top of the stack.","translation":"PUSHF ഫ്ലാഗ്സ് രജിസ്റ്ററിന്റെ ഇപ്പോഴത്തെ ഉള്ളടക്കം സ്റ്റാക്കിന്റെ മുകളിലേക്ക് തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"SP is decremented before the word goes onto the stack.","translation":"വാക്ക് സ്റ്റാക്കിലേക്ക് പോകുന്നതിന് മുമ്പ് SP കുറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"PUSHF and POPF are most used in writing interrupt service routines.","translation":"തടസ്സമില്ലാത്ത സേവന ദിനചര്യകൾ എഴുതുന്നതിനാണ് PUSHF, POPF എന്നിവ കൂടുതലായി ഉപയോഗിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHFD simply pushes the current contents of the 32-bit EFlags register onto the top of the stack.","translation":"PUSHFD 32-ബിറ്റ് EFlags രജിസ്റ്ററിന്റെ ഇപ്പോഴത്തെ ഉള്ളടക്കം സ്റ്റാക്കിന്റെ മുകളിലേക്ക് തള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"ESP is decremented before the EFlags double word goes onto the stack.","translation":"EFlags ഡബിൾ വേഡ് സ്റ്റാക്കിലേക്ക് പോകുന്നതിന് മുമ്പ് ESP കുറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"PUSHFD and POPFD are most used in writing interrupt service routines.","translation":"തടസ്സമില്ലാത്ത സേവന ദിനചര്യകൾ എഴുതുന്നതിനാണ് PUSHFD, POPFD എന്നിവ കൂടുതലായി ഉപയോഗിക്കുന്നത്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"There are two kinds of returns: Near and Far.","translation":"രണ്ട് തരത്തിലുള്ള റിട്ടേണുകളുണ്ട്: സമീപവും ദൂരവും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"RET may take an operand indicating how many bytes of stack space are to be released.","translation":"എത്ര ബൈറ്റുകളുടെ സ്റ്റാക്ക് സ്പേസ് റിലീസ് ചെയ്യണമെന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഓപ്പറാൻ്റ് RET-ന് എടുക്കാം.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"ROL rotates the bits within the destination operand to the left.","translation":"ROL ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡിനുള്ളിലെ ബിറ്റുകളെ ഇടത്തേക്ക് കറക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The number of bit positions shifted may be specified either as an 8-bit immediate value, or by the value in CL.","translation":"മാറ്റുന്ന ബിറ്റ് സ്ഥാനങ്ങളുടെ എണ്ണം ഒരു 8-ബിറ്റ് ഉടനടി മൂല്യമായിട്ടോ അല്ലെങ്കിൽ CL-ലെ മൂല്യമോ ആയി വ്യക്തമാക്കാം.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The leftmost bit of the operand is shifted into the Carry flag.","translation":"ഓപ്പറാൻഡിന്റെ ഏറ്റവും ഇടതുവശത്തുള്ള ബിറ്റ് കാരി ഫ്ലാഗിലേക്ക് മാറ്റുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"ROR rotates the bits within the destination operand to the right.","translation":"ROR ലക്ഷ്യസ്ഥാന ഓപ്പറാൻഡിനുള്ളിലെ ബിറ്റുകളെ വലത്തേക്ക് കറക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book provides a step-by-step guide to assembly language programming.","translation":"അസംബ്ലി ഭാഷാ പ്രോഗ്രാമിംഗിന്റെ ഘട്ടം ഘട്ടമായുള്ള ഒരു ഗൈഡ് ഈ പുസ്തകം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Assembly language is often used for low-level system programming.","translation":"താഴ്ന്ന നിലയിലുള്ള സിസ്റ്റം പ്രോഗ്രാമിംഗിനായി അസംബ്ലി ഭാഷ സാധാരണയായി ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Understanding memory addressing is crucial for assembly language.","translation":"മെമ്മറി വിലാസം മനസ്സിലാക്കുന്നത് അസംബ്ലി ഭാഷയ്ക്ക് വളരെ അത്യാവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The linker combines object files into an executable program.","translation":"ലിങ്കർ ഒബ്ജക്റ്റ് ഫയലുകളെ എക്സിക്യൂട്ടബിൾ പ്രോഗ്രാമായി സംയോജിപ്പിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Local labels are used within macros to avoid naming conflicts.","translation":"പേരിടൽ വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കാൻ, പ്രാദേശിക ലേബലുകൾ മാക്രോകളിൽ ഉപയോഗിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The book explains how to use the NASM assembler.","translation":"NASM അസംബ്ലർ എങ്ങനെ ഉപയോഗിക്കാമെന്ന് പുസ്തകത്തിൽ വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Linux provides a powerful environment for assembly programming.","translation":"അസംബ്ലി പ്രോഗ്രാമിംഗിനായി ശക്തമായ ഒരു അന്തരീക്ഷം Linux നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The text discusses the use of registers in assembly language.","translation":"അസംബ്ലി ഭാഷയിൽ രജിസ്റ്ററുകളുടെ ഉപയോഗത്തെക്കുറിച്ച് ഈ പാഠപുസ്തകത്തിൽ പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book covers the basics of machine code and assembly language.","translation":"മെഷീൻ കോഡിന്റെയും അസംബ്ലി ഭാഷയുടെയും അടിസ്ഥാന കാര്യങ്ങൾ ഈ പുസ്തകത്തിൽ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Understanding the stack is essential for writing assembly code.","translation":"അസംബ്ലി കോഡ് എഴുതുന്നതിന്, സ്റ്റാക്ക് മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains how to debug assembly programs using gdb.","translation":"gdb ഉപയോഗിച്ച് അസംബ്ലി പ്രോഗ്രാമുകൾ എങ്ങനെ ഡീബഗ് ചെയ്യാമെന്ന് പുസ്തകത്തിൽ വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The author provides examples of assembly language programs.","translation":"അസംബ്ലി ഭാഷാ പ്രോഗ്രാമുകളുടെ ഉദാഹരണങ്ങൾ രചയിതാവ് നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The book discusses the use of macros to simplify code.","translation":"കോഡ് ലളിതമാക്കാൻ മാക്രോകളുടെ ഉപയോഗത്തെക്കുറിച്ച് പുസ്തകത്തിൽ പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The text covers the different memory models used in assembly.","translation":"അസംബ്ലിയിൽ ഉപയോഗിക്കുന്ന വ്യത്യസ്ത മെമ്മറി മോഡലുകളെക്കുറിച്ച് ഈ പുസ്തകത്തിൽ പറയുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains how to handle interrupts in assembly language.","translation":"അസംബ്ലി ഭാഷയിൽ തടസ്സങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്ന് പുസ്തകത്തിൽ വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"The book is a valuable resource for learning assembly language.","translation":"അസംബ്ലി ഭാഷ പഠിക്കാൻ ഈ പുസ്തകം ഒരു വിലപ്പെട്ട resource ആണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"The book provides detailed explanations of assembly instructions.","translation":"അസംബ്ലി നിർദ്ദേശങ്ങളെക്കുറിച്ച് വിശദമായ വിശദീകരണങ്ങൾ ഈ പുസ്തകത്തിൽ നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The text covers the basics of bitwise operations in assembly.","translation":"അസംബ്ലിയിലെ ബിറ്റ് വൈസ് ഓപ്പറേഷനുകളുടെ അടിസ്ഥാന കാര്യങ്ങൾ ഈ പുസ്തകത്തിൽ ഉൾക്കൊള്ളുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The book explains how to use procedures and functions in assembly.","translation":"അസംബ്ലിയിൽ നടപടിക്രമങ്ങളും ഫംഗ്ഷനുകളും എങ്ങനെ ഉപയോഗിക്കാമെന്ന് പുസ്തകത്തിൽ വിശദീകരിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"This book is a great starting point for anyone interested in assembly language.","translation":"അസംബ്ലി ഭാഷയിൽ താൽപ്പര്യമുള്ള ഏതൊരാൾക്കും ഇതൊരു മികച്ച തുടക്കമാണ്.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"SUB performs a subtraction without borrow, where the source is subtracted from the destination, and the result replaces the destination.","translation":"കടം വാങ്ങാതെ കുറയ്ക്കൽ നടത്തുന്നത് SUB ആണ്, അവിടെ സോഴ്സ് ഡെസ്റ്റിനേഷനിൽ നിന്ന് കുറയ്ക്കുകയും ഫലം ഡെസ്റ്റിനേഷനെ മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"If the result is negative, the Carry flag is set.","translation":"ഫലം നെഗറ്റീവ് ആണെങ്കിൽ, കാരി ഫ്ലാഗ് സജ്ജീകരിക്കും.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Multiple-precision subtraction can be performed by following SUB with SBB (Subtract with Borrow) which takes the Carry flag into account as a borrow.","translation":"SBB (കടം വാങ്ങിയുള്ള കുറയ്ക്കൽ) ഉപയോഗിച്ച് SUB പിന്തുടർന്ന്, ഒന്നിലധികം കൃത്യതയുള്ള കുറയ്ക്കൽ നടത്താൻ കഴിയും, ഇത് കാരി ഫ്ലാഗിനെ ഒരു കടമായി കണക്കാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"XCHG exchanges the contents of its two operands.","translation":"XCHG അതിന്റെ രണ്ട് ഓപ്പറാൻ്റുകളുടെ ഉള്ളടക്കം കൈമാറ്റം ചെയ്യുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"This is why there is no form of XCHG for identical operands; that is, XCHG AX,AX is not a legal form since exchanging a register with itself makes no logical sense.","translation":"ഇതിനാലാണ്, XCHG-യുടെ സമാന ഓപ്പറാൻ്റുകൾ ഉണ്ടാകാത്തത്; അതായത്, XCHG AX,AX ഒരു നിയമപരമായ രൂപമല്ല, കാരണം ഒരു രജിസ്റ്ററിനെ അതുമായിത്തന്നെ കൈമാറ്റം ചെയ്യുന്നത് യുക്തിക്ക് നിരക്കുന്നതല്ല.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Exchanging an operand with AX may be accomplished with a single-byte opcode, saving fetch time and code space.","translation":"ഒരു ഓപ്പറാൻ്റിനെ AX-മായി കൈമാറ്റം ചെയ്യുന്നത് ഒരു സിംഗിൾ-ബൈറ്റ് ഓപ്കോഡ് ഉപയോഗിച്ച് ചെയ്യാവുന്നതാണ്, ഇത് ഫെച്ച് സമയവും കോഡ് സ്ഥലവും ലാഭിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"All good assemblers recognize these cases and optimize for them, but if you are hand-assembling INLINE statements for some high-level language, keep the single-byte special cases in mind.","translation":"എല്ലാ നല്ല അസംബ്ലറുകളും ഈ കേസുകൾ തിരിച്ചറിയുകയും അവയ്ക്കായി ഒപ്റ്റിമൈസ് ചെയ്യുകയും ചെയ്യുന്നു, എന്നാൽ നിങ്ങൾ ചില ഹൈ-ലെവൽ ഭാഷകൾക്കായി INLINE സ്റ്റേറ്റ്മെൻ്റുകൾ കൈകൊണ്ട് അസംബിൾ ചെയ്യുകയാണെങ്കിൽ, സിംഗിൾ-ബൈറ്റ് പ്രത്യേക കേസുകൾ ഓർമ്മയിൽ വയ്ക്കുക.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"XOR performs the exclusive OR logical operation between its two operands.","translation":"XOR അതിന്റെ രണ്ട് ഓപ്പറാൻ്റുകൾക്കിടയിൽ എക്സ്ക്ലൂസീവ് OR ലോജിക്കൽ പ്രവർത്തനം നടത്തുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"Once the operation is complete, the result replaces the destination operand.","translation":"പ്രവർത്തനം പൂർത്തിയായാൽ, ഫലം ലക്ഷ്യസ്ഥാന ഓപ്പറാൻ്റിനെ മാറ്റിസ്ഥാപിക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"XOR is performed on a bit-by-bit basis, such that bit 0 of the source is XORed with bit 0 of the destination, bit 1 of the source is XORed with bit 1 of the destination, and so on.","translation":"XOR ഒരു ബിറ്റ്-ബൈ-ബിറ്റ് അടിസ്ഥാനത്തിലാണ് നടത്തുന്നത്, അതായത് സോഴ്സിൻ്റെ ബിറ്റ് 0 ഡെസ്റ്റിനേഷൻ്റെ ബിറ്റ് 0-മായി XOR ചെയ്യപ്പെടുന്നു, സോഴ്സിൻ്റെ ബിറ്റ് 1 ഡെസ്റ്റിനേഷന്റെ ബിറ്റ് 1-മായി XOR ചെയ്യപ്പെടുന്നു, അങ്ങനെ തുടരുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"The XOR operation yields a 1 if the operands are different, and a 0 if the operands are the same.","translation":"ഓപ്പറാൻ്റുകൾ വ്യത്യസ്തമാണെങ്കിൽ XOR പ്രവർത്തനം 1 ഉം, ഓപ്പറാൻ്റുകൾ ഒന്നാണെങ്കിൽ 0 ഉം നൽകുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Note that the operation makes the Auxiliary carry flag undefined.","translation":"പ്രവർത്തനം ഓക്സിലറി കാരി ഫ്ലാഗിനെ നിർവചിക്കാത്തതാക്കുന്നു എന്നത് ശ്രദ്ധിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"CF and OF are cleared to 0, and the other affected flags are set according to the operation's results.","translation":"CF, OF എന്നിവ 0 ആയി മായ്ക്കുന്നു, കൂടാതെ മറ്റ് ബാധിച്ച ഫ്ലാഗുകൾ പ്രവർത്തനത്തിൻ്റെ ഫലങ്ങൾക്കനുസരിച്ച് സജ്ജമാക്കുന്നു.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"One reason the segmented modes are so awful is that there is a whole layer of assumptions to be remembered about which segments are used in which ways with which instructions, and what may be overridden with override prefixes.","translation":"സെഗ്മെൻ്റഡ് മോഡുകൾ ഇത്രയും മോശമാകാനുള്ള ഒരു കാരണം, ഏത് സെഗ്മെൻ്റുകളാണ് ഏത് രീതിയിൽ, ഏത് നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് ഉപയോഗിക്കുന്നത്, എന്ത് കാര്യങ്ങൾ ഓവർറൈഡ് പ്രിഫിക്സുകൾ ഉപയോഗിച്ച് ഓവർറൈഡ് ചെയ്യാൻ കഴിയും എന്നതിനെക്കുറിച്ച് ഓർമ്മിക്കേണ്ട ചില കാര്യങ്ങളുണ്ട്.","target_lang":"ml","domain":"technical","complexity":"complex"} | |
| {"en":"Keep in mind that this applies only to real mode segmented model.","translation":"ഇത് യഥാർത്ഥ മോഡ് സെഗ്മെൻ്റഡ് മോഡലിന് മാത്രമേ ബാധകമാകൂ എന്ന് ഓർമ്മിക്കുക.","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"In 32-bit protected mode (as in Linux), all the segments point to the same memory space, and thus you don't need to \"mess with\" segments and overrides.","translation":"32-ബിറ്റ് പ്രൊട്ടക്റ്റഡ് മോഡിൽ (Linux-ൽ എന്നപോലെ), എല്ലാ സെഗ്മെൻ്റുകളും ഒരേ മെമ്മറി സ്പേസിലേക്ക് പോയിൻ്റ് ചെയ്യുന്നു, അതിനാൽ നിങ്ങൾക്ക് സെഗ്മെൻ്റുകളും ഓവർറൈഡുകളും \"ശല്യപ്പെടുത്തേണ്ടതില്ല\".","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Where allowed, segment assumptions may be overridden with the segment override prefixes.","translation":"അനുവദനീയമായ സ്ഥലങ്ങളിൽ, സെഗ്മെൻ്റ് ഓവർറൈഡ് പ്രിഫിക്സുകൾ ഉപയോഗിച്ച് സെഗ്മെൻ്റ് അനുമാനങ്ങൾ ഓവർറൈഡ് ചെയ്യാവുന്നതാണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"Here's an example of such an override in action: mov [ES:BX],AX","translation":"ഇത്തരത്തിലുള്ള ഒന്നിൻ്റെ ഒരു ഉദാഹരണം ഇതാ: mov [ES:BX],AX","target_lang":"ml","domain":"technical","complexity":"simple"} | |
| {"en":"When the offset is specified in BX, SI, or DI, the assumed segment register is DS.","translation":"ഓഫ്സെറ്റ് BX, SI, അല്ലെങ്കിൽ DI എന്നിവയിൽ വ്യക്തമാക്കുമ്പോൾ, അനുമാനിക്കുന്ന സെഗ്മെൻ്റ് രജിസ്റ്റർ DS ആണ്.","target_lang":"ml","domain":"technical","complexity":"moderate"} | |
| {"en":"For string instruction LODS, the assumed segment is DS and the assumed offset is SI. This may not be overridden!","translation":"സ്ട്രിംഗ് ഇൻസ്ട്രക്ഷൻ LODS-ന്, അനുമാനിക്കുന്ന സെഗ്മെൻ്റ് DS ആണ്, കൂടാതെ അനുമാനിക്കുന്ന ഓഫ്സെറ്റ് SI ആണ്. ഇത് ഓവർറൈഡ് ചെയ്യാൻ കഴിയില്ല!","target_lang":"ml","domain":"technical","complexity":"moderate"} |