ഒരു കംപൈലർ എന്നാൽ എന്താണ്?


ഒരു കംപൈലറിൻ്റെ ഘട്ടങ്ങൾ പ്രധാനമാണ്.


Interpreters are also used in programming.

പ്രോഗ്രാമിംഗിൽ ഇന്റർപ്രറ്ററുകളും ഉപയോഗിക്കുന്നു.


എന്തുകൊണ്ടാണ് കംപൈലറുകളെക്കുറിച്ച് പഠിക്കേണ്ടത്?


The structure of this book is well-organized.

ഈ പുസ്തകത്തിന്റെ ഘടന നന്നായി ക്രമീകരിച്ചിരിക്കുന്നു.


പ്രഭാഷകന് എൻ്റെ നന്ദി അറിയിക്കുന്നു.


Permission to use the content is granted.

ഉള്ളടക്കം ഉപയോഗിക്കാൻ അനുമതിയുണ്ട്.


ലെക്സിക്കൽ അനാലിസിസ് ആദ്യത്തെ ഘട്ടമാണ്.


റഗുലർ എക്സ്പ്രഷൻസ് ശക്തമായ ഉപകരണങ്ങളാണ്.


ചുരുക്കെഴുത്തുകൾക്ക് എക്സ്പ്രഷനുകൾ ലളിതമാക്കാൻ കഴിയും.


ചില ഉദാഹരണങ്ങൾ നോക്കാം.


Nondeterministic finite automata are complex.

നോൺഡിറ്റർമിനിസ്റ്റിക് ഫൈനൈറ്റ് ഓട്ടോമാറ്റ സങ്കീർണ്ണമാണ്.


Converting a regular expression to an NFA is a key process.

ഒരു റെഗുലർ എക്സ്പ്രഷനെ NFA ആക്കി മാറ്റുന്നത് ഒരു പ്രധാന പ്രക്രിയയാണ്.


ഒപ്റ്റിമൈസേഷനുകൾക്ക് പ്രകടനം മെച്ചപ്പെടുത്താൻ കഴിയും.


Deterministic finite automata are easier to understand.

നിർണ്ണായകമായ ഫൈനൈറ്റ് ഓട്ടോമാറ്റ മനസ്സിലാക്കാൻ എളുപ്പമാണ്.


Converting an NFA to a DFA is a crucial step.

ഒരു NFA-യെ DFA ആക്കി മാറ്റുന്നത് ഒരു നിർണായക ഘട്ടമാണ്.


Size versus speed is an important trade-off.

വലിപ്പവും വേഗതയും തമ്മിലുള്ള ബന്ധം ഒരു പ്രധാന ഒത്തുതീർപ്പാണ്.


Minimization of DFAs is a useful technique.

DFA-കളുടെ ലഘൂകരണം ഒരു ഉപയോഗപ്രദമായ സാങ്കേതികതയാണ്.


ലെക്സർ ജനറേറ്ററുകൾ ഈ പ്രക്രിയയെ ഓട്ടോമേറ്റ് ചെയ്യുന്നു.


Properties of regular languages are well-defined.

റെഗുലർ ഭാഷകളുടെ സവിശേഷതകൾ നന്നായി നിർവചിക്കപ്പെട്ടിരിക്കുന്നു.


The program uses floating-point numbers for calculations.

പ്രോഗ്രാം കണക്കുകൂട്ടലുകൾക്കായി ഫ്ലോട്ടിംഗ്-പോയിന്റ് സംഖ്യകൾ ഉപയോഗിക്കുന്നു.


A floating-point constant can have an optional sign.

ഒരു ഫ്ലോട്ടിംഗ്-പോയിന്റ് സ്ഥിരാങ്കത്തിന് ഒരു ഓപ്ഷണൽ ചിഹ്നം ഉണ്ടാകാം.


The mantissa part is described as a sequence of digits.

മാൻ്റിസ്സ ഭാഗം അക്കങ്ങളുടെ ഒരു ശ്രേണിയായി വിവരിക്കുന്നു.


String constants start with a quotation mark.

സ്ട്രിംഗ് സ്ഥിരാങ്കങ്ങൾ ഒരു ഉദ്ധരണ ചിഹ്നത്തിൽ ആരംഭിക്കുന്നു.


We use nondeterministic finite automata as a stepping stone.

നോൺഡിറ്റർമിനിസ്റ്റിക് ഫൈനൈറ്റ് ഓട്ടോമാറ്റ (NFA) ഒരു മുന്നേറ്റമായി നമ്മൾ ഉപയോഗിക്കുന്നു.


A finite automaton has a finite number of states.

ഒരു ഫൈനൈറ്റ് ഓട്ടോമാറ്റയ്ക്ക് പരിമിതമായ എണ്ണം സ്റ്റേറ്റുകൾ ഉണ്ട്.


Transitions are usually labelled by a character.

സംക്രമണങ്ങൾ സാധാരണയായി ഒരു പ്രതീകം ഉപയോഗിച്ച് ലേബൽ ചെയ്യാവുന്നതാണ്.


നമ്മൾ എപ്സിലോൺ ട്രാൻസിഷനുകളും ഉപയോഗിക്കും.


The string is in the language defined by the automaton.

സ്ട്രിംഗ് ഓട്ടോമാറ്റൺ നിർവചിച്ചിട്ടുള്ള ഭാഷയിലാണ്.


The choice of action is not determined solely by looking at the current state.

പ്രവർത്തി ചെയ്യേണ്ട രീതി നിലവിലെ അവസ്ഥ മാത്രം നോക്കി തീരുമാനിക്കുന്നില്ല.


We can formally define a nondeterministic finite automaton.

നോൺഡിറ്റർമിനിസ്റ്റിക് ഫൈനൈറ്റ് ഓട്ടോമാറ്റയെ നമുക്ക് ഔപചാരികമായി നിർവചിക്കാം.


ഓട്ടോമാറ്റയുടെ ആരംഭ അവസ്ഥ.


Accepting states can also be called final states.

സ്വീകരിക്കുന്ന അവസ്ഥകളെ അവസാന അവസ്ഥകൾ എന്നും വിളിക്കാം.


We use the abbreviations FA for finite automaton.

ഫൈനൈറ്റ് ഓട്ടോമാറ്റക്ക് വേണ്ടി FA എന്ന ചുരുക്കെഴുത്ത് നമ്മൾ ഉപയോഗിക്കുന്നു.


അവസ്ഥകൾ വൃത്തങ്ങൾ ഉപയോഗിച്ച് സൂചിപ്പിക്കുന്നു.


The initial state is marked by an arrow.

ആരംഭ അവസ്ഥ ഒരു അമ്പടയാളം ഉപയോഗിച്ച് അടയാളപ്പെടുത്തിയിരിക്കുന്നു.


ചിത്രം 2.3 ഒരു NFA-യുടെ ഉദാഹരണം കാണിക്കുന്നു.


This NFA recognises the language described by the regular expression.

ഈ NFA റെഗുലർ എക്സ്പ്രഷൻ ഉപയോഗിച്ച് വിവരിക്കുന്ന ഭാഷയെ തിരിച്ചറിയുന്നു.


A program that decides if a string is accepted.

ഒരു സ്ട്രിംഗ് സ്വീകാര്യമാണോ എന്ന് തീരുമാനിക്കുന്ന ഒരു പ്രോഗ്രാം.


We will construct an NFA compositionally from a regular expression.

ഒരു റെഗുലർ എക്സ്പ്രഷനിൽ നിന്ന് ഘടനാപരമായി ഒരു NFA നമ്മൾ നിർമ്മിക്കും.


The compiler translates a high-level programming language into machine language.

കംപൈലർ ഒരു ഉയർന്ന തലത്തിലുള്ള പ്രോഗ്രാമിംഗ് ഭാഷയെ മെഷീൻ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.


During this process, the compiler will also attempt to spot and report obvious programmer mistakes.

ഈ പ്രക്രിയയിൽ, വ്യക്തമായ പ്രോഗ്രാമർ തെറ്റുകൾ കണ്ടെത്താനും റിപ്പോർട്ട് ചെയ്യാനും കംപൈലർ ശ്രമിക്കും.


Using a high-level language for programming has a large impact on how fast programs can be developed.

പ്രോഗ്രാമിംഗിനായി ഉയർന്ന തലത്തിലുള്ള ഭാഷ ഉപയോഗിക്കുന്നത് പ്രോഗ്രാമുകൾ എത്ര വേഗത്തിൽ വികസിപ്പിക്കാൻ കഴിയും എന്നതിൽ വലിയ സ്വാധീനം ചെലുത്തുന്നു.


The compiler can spot some obvious programming mistakes.

കംപൈലറിന് ചില വ്യക്തമായ പ്രോഗ്രാമിംഗ് തെറ്റുകൾ കണ്ടെത്താൻ കഴിയും.


Programs written in a high-level language tend to be shorter than equivalent programs written in machine language.

ഉയർന്ന തലത്തിലുള്ള ഭാഷയിൽ എഴുതിയ പ്രോഗ്രാമുകൾ, മെഷീൻ ഭാഷയിൽ എഴുതിയ തത്തുല്യമായ പ്രോഗ്രാമുകളേക്കാൾ ചെറുതായിരിക്കും.


Another advantage of using a high-level level language is that the same program can be compiled to many different machine languages.

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


Hence, some time-critical programs are still written partly in machine language.

അതുകൊണ്ട്, ചില സമയ-നിർണ്ണായക പ്രോഗ്രാമുകൾ ഇപ്പോഴും ഭാഗികമായി മെഷീൻ ഭാഷയിൽ എഴുതപ്പെടുന്നു.


A good compiler will, however, be able to get very close to the speed of hand-written machine code when translating well-structured programs.

എന്നാൽ, നന്നായി ഘടന നൽകിയിട്ടുള്ള പ്രോഗ്രാമുകൾ വിവർത്തനം ചെയ്യുമ്പോൾ, കൈകൊണ്ട് എഴുതിയ മെഷീൻ കോഡിന്റെ വേഗതയോടടുക്കാൻ ഒരു നല്ല കംപൈലറിന് കഴിയും.


A typical way of doing this is to split the compilation into several phases with well-defined interfaces.

ഇത് ചെയ്യുന്നതിനുള്ള ഒരു സാധാരണ മാർഗ്ഗം, കംപൈലേഷൻ നന്നായി നിർവചിക്കപ്പെട്ട ഇന്റർഫേസുകളുള്ള നിരവധി ഘട്ടങ്ങളായി വിഭജിക്കുക എന്നതാണ്.


Conceptually, these phases operate in sequence.

സങ്കൽപ്പപരമായി, ഈ ഘട്ടങ്ങൾ ഒരു ശ്രേണിയിൽ പ്രവർത്തിക്കുന്നു.


Lexical analysis is the initial part of reading and analysing the program text.

പ്രോഗ്രാം ടെക്സ്റ്റ് വായിക്കുന്നതിൻ്റെയും വിശകലനം ചെയ്യുന്നതിൻ്റെയും പ്രാരംഭ ഭാഗമാണ് ലെക്സിക്കൽ അനാലിസിസ്.


The text is read and divided into tokens.

ടെക്സ്റ്റ് വായിച്ച് ടോക്കണുകളായി വിഭജിക്കപ്പെടുന്നു.


Syntax analysis arranges tokens in a tree-structure.

സിന്റാക്സ് അനാലിസിസ് ടോക്കണുകളെ ഒരു ട്രീ-ഘടനയിൽ ക്രമീകരിക്കുന്നു.


ഈ ഘട്ടത്തെ പലപ്പോഴും പാഴ്സിംഗ് എന്ന് വിളിക്കുന്നു.


Type checking determines if the program violates consistency requirements.

പ്രോഗ്രാം സ്ഥിരത ആവശ്യകതകൾ ലംഘിക്കുന്നുണ്ടോ എന്ന് ടൈപ്പ് പരിശോധന നിർണ്ണയിക്കുന്നു.


For example, if a variable is used but not declared.

ഉദാഹരണത്തിന്, ഒരു വേരിയബിൾ ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും പ്രഖ്യാപിച്ചിട്ടില്ലെങ്കിൽ.


Memory management is a crucial aspect of programming.

മെമ്മറി മാനേജ്മെൻ്റ് പ്രോഗ്രാമിംഗിൻ്റെ ഒരു പ്രധാന ഘടകമാണ്.


Static allocation is one method of memory management.

മെമ്മറി മാനേജ്മെൻ്റിൻ്റെ ഒരു രീതിയാണ് സ്ഥിരമായ വിതരണം.


Heap allocation is another important technique.

കൂമ്പാര വിതരണം മറ്റൊരു പ്രധാന സാങ്കേതികതയാണ്.


Bootstrapping a compiler involves compiling compilers.

ഒരു കംപൈലർ ബൂട്ട്‌സ്‌ട്രാപ്പിംഗിൽ കംപൈലറുകൾ കംപൈൽ ചെയ്യുന്നത് ഉൾപ്പെടുന്നു.


The compiler translates the program into machine code.

കംപൈലർ പ്രോഗ്രാമിനെ മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.


Lexical analysis is the first phase of compilation.

സമാഹരണത്തിന്റെ ആദ്യ ഘട്ടമാണ് ലെക്സിക്കൽ അനാലിസിസ്.


Regular expressions are used to define tokens.

ടോക്കണുകൾ നിർവചിക്കാൻ റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുന്നു.


The syntax tree is processed to evaluate expressions.

എക്സ്പ്രഷനുകൾ വിലയിരുത്തുന്നതിന് സിന്റാക്സ് ട്രീ പ്രോസസ്സ് ചെയ്യുന്നു.


Interpreters execute statements directly from the syntax tree.

ഇന്റർപ്രെറ്ററുകൾ സിന്റാക്സ് ട്രീയിൽ നിന്ന് നേരിട്ട് പ്രസ്താവനകൾ നടപ്പിലാക്കുന്നു.


Understanding compilers helps programmers write more efficient code.

കംപൈലറുകളെക്കുറിച്ച് മനസ്സിലാക്കുന്നത് പ്രോഗ്രാമർമാരെ കൂടുതൽ കാര്യക്ഷമമായ കോഡ് എഴുതാൻ സഹായിക്കുന്നു.


Domain-specific languages are becoming increasingly popular.

ഡൊമെയ്ൻ-നിർദ്ദിഷ്ട ഭാഷകൾ കൂടുതൽ പ്രചാരം നേടുകയാണ്.


The book discusses lexical analysis and syntax analysis.

പുസ്തകത്തിൽ ലെക്സിക്കൽ അനാലിസിസിനെയും സിന്റാക്സ് അനാലിസിസിനെയും കുറിച്ച് പറയുന്നു.


Assembly and linking are typically done by the operating system.

അസംബ്ലിംഗും ലിങ്കിംഗും സാധാരണയായി ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണ് ചെയ്യുന്നത്.


The compiler's front-end handles lexical and syntax analysis.

കംപൈലറിന്റെ മുൻഭാഗം ലെക്സിക്കൽ, സിന്റാക്സ് വിശകലനം കൈകാര്യം ചെയ്യുന്നു.


The middle part of the compiler often includes optimizations.

കംപൈലറിന്റെ മധ്യഭാഗത്ത് പലപ്പോഴും ഒപ്റ്റിമൈസേഷനുകൾ ഉൾപ്പെടുന്നു.


ഒരു നല്ല കരകൗശല വിദഗ്ധൻ തന്റെ ഉപകരണങ്ങളെക്കുറിച്ച് അറിയണം.


The techniques used for constructing a compiler are useful for other purposes as well.

ഒരു കംപൈലർ നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന സാങ്കേതിക വിദ്യകൾ മറ്റ് ആവശ്യങ്ങൾക്കും ഉപയോഗപ്രദമാണ്.


The error reports that compilers provide are often easier to understand when one knows about the different phases of compilation.

കംപൈലറുകൾ നൽകുന്ന പിശക് റിപ്പോർട്ടുകൾ, സമാഹരണത്തിന്റെ വിവിധ ഘട്ടങ്ങളെക്കുറിച്ച് അറിയുമ്പോൾ മനസ്സിലാക്കാൻ എളുപ്പമാണ്.


Lexical analysis divides the input text into tokens.

ലെക്സിക്കൽ അനാലിസിസ് ഇൻപുട്ട് ടെക്സ്റ്റിനെ ടോക്കണുകളായി വിഭജിക്കുന്നു.


The main purpose of lexical analysis is to make life easier for the subsequent syntax analysis phase.

തുടർന്നുള്ള സിന്റാക്സ് അനാലിസിസ് ഘട്ടത്തിന് ജീവിതം എളുപ്പമാക്കുക എന്നതാണ് ലെക്സിക്കൽ അനാലിസിസിന്റെ പ്രധാന ലക്ഷ്യം.


A lexer may do the simple parts of the work faster than the more general parser can.

ഒരു ലെക്സറിന് കൂടുതൽ പൊതുവായ പാഴ്സറിന് കഴിയുന്നതിനേക്കാൾ വേഗത്തിൽ ലളിതമായ ഭാഗങ്ങൾ ചെയ്യാൻ കഴിയും.


Languages are often designed with separate lexical and syntactical phases in mind.

പ്രത്യേക ലെക്സിക്കൽ, സിന്റാക്റ്റിക്കൽ ഘട്ടങ്ങൾ മനസ്സിൽ വെച്ചാണ് പലപ്പോഴും ഭാഷകൾ രൂപകൽപ്പന ചെയ്യുന്നത്.


Regular expressions are an algebraic notation for describing sets of strings.

സ്ട്രിംഗുകളുടെ സെറ്റുകൾ വിവരിക്കുന്നതിനുള്ള ബീജഗണിത രൂപമാണ് റെഗുലർ എക്സ്പ്രഷനുകൾ.


The generated lexers are in a class of extremely simple programs called finite automata.

നിർമ്മിച്ച ലെക്സറുകൾ ഫൈനൈറ്റ് ഓട്ടോമാറ്റ എന്ന് വിളിക്കപ്പെടുന്ന വളരെ ലളിതമായ പ്രോഗ്രാമുകളുടെ ഒരു വിഭാഗത്തിലാണ്.


The DFA constructed from this combined regular expression will scan for all token types at the same time.

ഈ സംയോജിത റെഗുലർ എക്സ്പ്രഷനിൽ നിന്ന് നിർമ്മിച്ച DFA ഒരേ സമയം എല്ലാ ടോക്കൺ തരങ്ങളും സ്കാൻ ചെയ്യും.


A lexer has to distinguish between several different types of tokens, e.g., numbers, variables and keywords.

ഒരു ലെക്സർ വ്യത്യസ്ത തരം ടോക്കണുകൾ, അതായത്, സംഖ്യകൾ, വേരിയബിളുകൾ, കീവേഡുകൾ എന്നിവ തമ്മിൽ വേർതിരിക്കേണ്ടതുണ്ട്.


Each of these are described by its own regular expression.

ഇവയോരോന്നും അതിൻ്റേതായ റെഗുലർ എക്സ്പ്രഷൻ ഉപയോഗിച്ച് വിവരിക്കുന്നു.


If there are several ways to split the input into legal tokens, the lexer has to decide which of these it should use.

ഇൻപുട്ടിനെ നിയമപരമായ ടോക്കണുകളായി വിഭജിക്കാൻ നിരവധി വഴികളുണ്ടെങ്കിൽ, ലെക്സർ ഏതാണ് ഉപയോഗിക്കേണ്ടതെന്ന് തീരുമാനിക്കണം.


A program that takes a set of token definitions and generates a lexer is called a lexer generator.

ടോക്കൺ നിർവചനങ്ങളുടെ ഒരു കൂട്ടം എടുത്ത് ഒരു ലെക്സർ ഉണ്ടാക്കുന്ന പ്രോഗ്രാമിനെ ലെക്സർ ജനറേറ്റർ എന്ന് വിളിക്കുന്നു.


The simplest approach would be to generate a DFA for each token definition and apply the DFAs one at a time to the input.

ഏറ്റവും ലളിതമായ സമീപനം ഓരോ ടോക്കൺ നിർവചനത്തിനും ഒരു DFA ഉണ്ടാക്കുകയും ഇൻപുട്ടിലേക്ക് ഒന്നൊന്നായി DFAs പ്രയോഗിക്കുകയും ചെയ്യുക എന്നതാണ്.


This can, however, be quite slow, so we will instead from the set of token definitions generate a single DFA that tests for all the tokens simultaneously.

എങ്കിലും ഇത് വളരെ വേഗത കുറഞ്ഞതാകാം, അതിനാൽ ടോക്കൺ നിർവചനങ്ങളുടെ കൂട്ടത്തിൽ നിന്ന് എല്ലാ ടോക്കണുകളും ഒരേസമയം പരിശോധിക്കുന്ന ഒരു DFA ഞങ്ങൾ ഉണ്ടാക്കും.


If the tokens are defined by regular expressions r1, r2, ..., rn, then the regular expression r1 | r2 | ... | rn describes the union of the languages r1, r2, ..., rn.

ടോക്കണുകൾ r1, r2, ..., rn എന്നീ റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് നിർവചിച്ചിട്ടുണ്ടെങ്കിൽ, r1 | r2 | ... | rn എന്ന റെഗുലർ എക്സ്പ്രഷൻ r1, r2, ..., rn എന്നീ ഭാഷകളുടെ യൂണിയനെ വിവരിക്കുന്നു.


However, we also wish to distinguish between different token types, so we must be able to know which of the many tokens was recognised by the DFA.

എങ്കിലും, വ്യത്യസ്ത ടോക്കൺ തരങ്ങൾ തമ്മിൽ വേർതിരിക്കാനും ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അതിനാൽ DFA തിരിച്ചറിഞ്ഞ നിരവധി ടോക്കണുകളിൽ ഏതാണെന്ന് അറിയാൻ കഴിയണം.


The easiest way to do this is: Construct NFAs N1, N2, ..., Nn for each of r1, r2, ..., rn.

ഇത് ചെയ്യുന്നതിനുള്ള എളുപ്പവഴി ഇതാ: r1, r2, ..., rn എന്നിവയിൽ ഓരോന്നിനും NFAs N1, N2, ..., Nn ഉണ്ടാക്കുക.


Mark the accepting states of the NFAs by the name of the tokens they accept.

അംഗീകരിക്കുന്ന NFAs-ൻ്റെ അവസ്ഥകൾ അവ സ്വീകരിക്കുന്ന ടോക്കണുകളുടെ പേര് ഉപയോഗിച്ച് അടയാളപ്പെടുത്തുക.


Combine the NFAs to a single NFA by adding a new starting state which has epsilon-transitions to each of the starting states of the NFAs.

NFAs-ൻ്റെ ആരംഭ അവസ്ഥകളിലേക്ക് എപ്സിലോൺ-ട്രാൻസിഷനുകളുള്ള ഒരു പുതിയ ആരംഭ അവസ്ഥ ചേർത്ത് NFAs-നെ ഒരൊറ്റ NFA-യിലേക്ക് സംയോജിപ്പിക്കുക.


സംയോജിപ്പിച്ച NFA-യെ ഒരു DFA ആക്കി മാറ്റുക.


Each accepting state of the DFA consists of a set of NFA states, some of which are accepting states which we marked by token type.

DFA-യുടെ ഓരോ സ്വീകാര്യമായ അവസ്ഥയും NFA അവസ്ഥകളുടെ ഒരു കൂട്ടം ഉൾക്കൊള്ളുന്നു, അതിൽ ചിലത് ടോക്കൺ തരം അനുസരിച്ച് ഞങ്ങൾ അടയാളപ്പെടുത്തിയ സ്വീകാര്യമായ അവസ്ഥകളാണ്.


If the same accepting state in the DFA can accept several different token types, it is because these overlap.

DFA-യിലെ ഒരേ സ്വീകാര്യമായ അവസ്ഥയ്ക്ക് വ്യത്യസ്ത ടോക്കൺ തരങ്ങൾ സ്വീകരിക്കാൻ കഴിയുമെങ്കിൽ, അത് ഇവ തമ്മിൽ ഓവർലാപ്പ് ചെയ്യുന്നതിനാലാണ്.


This is not unusual, as keywords usually overlap with variable names and a description of floating-point constants may include integer constants as well.

സാധാരണയായി കീവേഡുകൾ വേരിയബിൾ പേരുകളുമായി ഓവർലാപ്പ് ചെയ്യുന്നതിനാലും, ഫ്ലോട്ടിംഗ്-പോയിൻ്റ് സ്ഥിരതകളെക്കുറിച്ചുള്ള വിവരണം പൂർണ്ണസംഖ്യാ സ്ഥിരതകളെയും ഉൾക്കൊള്ളുന്നതിനാലും ഇത് അസാധാരണമല്ല.


Let the lexer generator generate an error and require the user to make sure the tokens are disjoint.

ലെക്സർ ജനറേറ്റർ ഒരു പിശക് ഉണ്ടാക്കുകയും ടോക്കണുകൾ വേർതിരിക്കപ്പെട്ടിട്ടുണ്ടെന്ന് ഉപയോക്താവ് ഉറപ്പാക്കുകയും ചെയ്യുക.


Let the user of the lexer generator choose which of the tokens is preferred.

ലെക്സർ ജനറേറ്ററിൻ്റെ ഉപയോക്താവിനെ ടോക്കണുകളിൽ ഏതാണ് തിരഞ്ഞെടുക്കേണ്ടതെന്ന് തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുക.


It can be quite difficult with regular expressions to define, e.g., the set of names that are not keywords.

ഉദാഹരണത്തിന്, കീവേഡുകൾ അല്ലാത്ത പേരുകൾ നിർവചിക്കാൻ റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുന്നത് വളരെ ബുദ്ധിമുട്ടാണ്.


Hence, it is common to let the lexer choose according to a prioritised list.

അതുകൊണ്ട്, മുൻഗണനാ ലിസ്റ്റ് അനുസരിച്ച് ലെക്സറിനെ തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്നത് സാധാരണമാണ്.


കംപൈലർ കോഡ് വിശകലനം ചെയ്യുന്നു.


Precedence rules are crucial for expression syntax.

പ്രകടന ശൈലിക്ക് മുൻഗണനാ നിയമങ്ങൾ അത്യാവശ്യമാണ്.


വ്യാകരണത്തിലെ അവ്യക്തത ഒരു പ്രശ്നമായേക്കാം.


The 'dangling-else' problem is a classic example.

'ഡാങ്‌ലിംഗ്-എൽസ്' പ്രശ്നം ഒരു ക്ലാസിക് ഉദാഹരണമാണ്.


Conditional statements often have optional else parts.

നിബന്ധനാപരമായ പ്രസ്താവനകളിൽ പലപ്പോഴും ഓപ്ഷണൽ എൽസ് ഭാഗങ്ങൾ ഉണ്ടാകാറുണ്ട്.


വ്യാകരണം അവ്യക്തമല്ലാത്തതാകണം.


Syntax trees are constructed during syntax analysis.

സിന്റാക്സ് വിശകലന സമയത്ത് സിന്റാക്സ് ട്രീകൾ നിർമ്മിക്കപ്പെടുന്നു.


പ്രവചനപരമായ പാർസിംഗ് രീതികൾ ഉപയോഗിക്കുന്നു.


Top-down parsers build the tree from the root.

മുകളിൽ നിന്ന് താഴേക്കുള്ള പാർസറുകൾ റൂട്ടിൽ നിന്ന് ട്രീ ഉണ്ടാക്കുന്നു.


താഴെ നിന്ന് മുകളിലേക്കുള്ള പാർസിംഗ് രീതികളും ഉണ്ട്.


The parser chooses the correct production.

പാർസർ ശരിയായ പ്രൊഡക്ഷൻ തിരഞ്ഞെടുക്കുന്നു.


ഇൻപുട്ട് ചിഹ്നം തിരഞ്ഞെടുക്കാൻ സഹായിക്കുന്നു.


പ്രവചനപരമായ പാർസിംഗിൽ FIRST സെറ്റുകൾ സഹായിക്കുന്നു.


Nullable and FIRST functions are defined.

Nullable, FIRST ഫംഗ്ഷനുകൾ നിർവചിക്കപ്പെട്ടിരിക്കുന്നു.


The calculation of FIRST involves iteration.

FIRST കണക്കുകൂട്ടലിൽ ആവർത്തനം ഉൾപ്പെടുന്നു.


നമുക്ക് പ്രവചനപരമായ പാർസറുകൾ നിർമ്മിക്കാൻ കഴിയും.


വേർതിരിച്ച FIRST സെറ്റുകൾ ആവശ്യമാണ്.


അവ്യക്തമായ വ്യാകരണങ്ങളെ നിരസിക്കാൻ കഴിയും.


ഇതിനായി FOLLOW സെറ്റുകൾ അവതരിപ്പിക്കുന്നു.


LL(1) പാർസിംഗ് ഒരു തരം പാർസിംഗാണ്.


where φ is the regular expression for the empty language (see exercise 2.10).

ശൂന്യ ഭാഷയുടെ റെഗുലർ എക്സ്പ്രഷൻ ആണ് φ (അഭ്യാസം 2.10 കാണുക).


a) Complete the definition of non empty by replacing the occurrences of “...” in the rules above by expressions similar to those shown in the rules for ε and s|t.

a) മുകളിലെ നിയമങ്ങളിൽ “...” വരുന്നിടത്ത്, ε, s|t എന്നിവയുടെ നിയമങ്ങളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, നോൺ-എംപ്റ്റിയുടെ നിർവചനം പൂർത്തിയാക്കുക.


b) Use this definition to find non empty(a * b * ).

b) ഈ നിർവചനം ഉപയോഗിച്ച് നോൺ എംറ്റി(a * b * ) കണ്ടെത്തുക.


Exercise 2.16 If L is a regular language, so is the set of all prefixes of strings in L (see section 2.10.3).

അഭ്യാസം 2.16 L ഒരു സാധാരണ ഭാഷയാണെങ്കിൽ, L-ലെ സ്ട്രിംഗുകളുടെ എല്ലാ പ്രിഫിക്സുകളുടെയും കൂട്ടവും അങ്ങനെതന്നെയാണ് (വകുപ്പ് 2.10.3 കാണുക).


So we should be able to transform a regular expression for L into a regular expression for the set of all prefixes of strings in L.

അതിനാൽ L-ന്റെ റെഗുലർ എക്സ്പ്രഷനെ L-ലെ സ്ട്രിംഗുകളുടെ എല്ലാ പ്രിഫിക്സുകളുടെയും കൂട്ടത്തിനായുള്ള റെഗുലർ എക്സ്പ്രഷനായി മാറ്റാൻ നമുക്ക് കഴിയണം.


We want to do this with a function prefixes that is recursive over the structure of the regular expression for L, i.e., of the form:

L-ന്റെ റെഗുലർ എക്സ്പ്രഷന്റെ ഘടനയിൽ ആവർത്തിക്കുന്ന ഒരു ഫംഗ്ഷൻ പ്രിഫിക്സുകൾ ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അതായത്:


prefixes(a) = a? where a is an alphabet symbol

prefixes(a) = a? ഇവിടെ a ഒരു അക്ഷരമാല ചിഹ്നമാണ്


a) Complete the definition of prefixes by replacing the occurrences of “...” in the rules above by expressions similar to those shown in the rules for ε, a and s|t.

a) മുകളിലെ നിയമങ്ങളിൽ “...” വരുന്നിടത്ത്, ε, a, s|t എന്നിവയുടെ നിയമങ്ങളിൽ കാണിച്ചിരിക്കുന്നതുപോലെ, പ്രിഫിക്സുകളുടെ നിർവചനം പൂർത്തിയാക്കുക.


b) Use this definition to find prefixes(ab * c).

b) ഈ നിർവചനം ഉപയോഗിച്ച് prefixes(ab * c) കണ്ടെത്തുക.


Chapter 3 Syntax Analysis 3.1 Introduction Where lexical analysis splits the input into tokens, the purpose of syntax analysis (also known as parsing) is to recombine these tokens.

അദ്ധ്യായം 3 സിന്റാക്സ് അനാലിസിസ് 3.1 ആമുഖം ലെക്സിക്കൽ അനാലിസിസ് ഇൻപുട്ടിനെ ടോക്കണുകളായി വിഭജിക്കുമ്പോൾ, സിന്റാക്സ് അനാലിസിസിന്റെ (പാഴ്സിംഗ് എന്നും അറിയപ്പെടുന്നു) ലക്ഷ്യം ഈ ടോക്കണുകളെ വീണ്ടും സംയോജിപ്പിക്കുക എന്നതാണ്.


Not back into a list of characters, but into something that reflects the structure of the text.

അക്ഷരങ്ങളുടെ ഒരു ലിസ്റ്റിലേക്ക് അല്ല, ടെക്സ്റ്റിന്റെ ഘടനയെ പ്രതിഫലിപ്പിക്കുന്ന ഒന്നിലേക്ക്.


This “something” is typically a data structure called the syntax tree of the text.

ഈ “ഒന്ന്” സാധാരണയായി ടെക്സ്റ്റിന്റെ സിന്റാക്സ് ട്രീ എന്ന് വിളിക്കപ്പെടുന്ന ഒരു ഡാറ്റാ ഘടനയാണ്.


As the name indicates, this is a tree structure.

പേര് സൂചിപ്പിക്കുന്നത് പോലെ, ഇതൊരു ട്രീ ഘടനയാണ്.


The leaves of this tree are the tokens found by the lexical analysis, and if the leaves are read from left to right, the sequence is the same as in the input text.

ഈ ട്രീയുടെ ഇലകൾ ലെക്സിക്കൽ അനാലിസിസ് കണ്ടെത്തിയ ടോക്കണുകളാണ്, കൂടാതെ ഇലകൾ ഇടത്തുനിന്ന് വലത്തോട്ട് വായിച്ചാൽ, ശ്രേണി ഇൻപുട്ട് ടെക്സ്റ്റിലേതിന് തുല്യമാണ്.


Hence, what is important in the syntax tree is how these leaves are combined to form the structure of the tree and how the interior nodes of the tree are labelled.

അതുകൊണ്ട്, സിന്റാക്സ് ട്രീയിൽ പ്രധാനമായിട്ടുള്ളത്, ഈ ഇലകൾ എങ്ങനെ സംയോജിപ്പിച്ച് ട്രീയുടെ ഘടന ഉണ്ടാക്കുന്നു, അതുപോലെ ട്രീയുടെ ഉൾഭാഗത്തുള്ള നോഡുകൾക്ക് എങ്ങനെ ലേബൽ നൽകുന്നു എന്നതാണ്.


The program uses functions to choose productions for nonterminals.

പ്രോഗ്രാം നോൺടെർമിനലുകൾക്കായി പ്രൊഡക്ഷനുകൾ തിരഞ്ഞെടുക്കാൻ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നു.


A terminal on the right-hand side is matched against the next input symbol.

വലതുവശത്തുള്ള ഒരു ടെർമിനൽ അടുത്ത ഇൻപുട്ട് ചിഹ്നവുമായി പൊരുത്തപ്പെടുന്നു.


If they match, we move on to the following input symbol.

അവ പൊരുത്തപ്പെടുന്നെങ്കിൽ, ഞങ്ങൾ അടുത്ത ഇൻപുട്ട് ചിഹ്നത്തിലേക്ക് നീങ്ങുന്നു.


A nonterminal on the right-hand side is handled by calling the corresponding function.

വലതുവശത്തുള്ള ഒരു നോൺടെർമിനൽ, അനുബന്ധ ഫംഗ്ഷൻ വിളിക്കുന്നതിലൂടെ കൈകാര്യം ചെയ്യപ്പെടുന്നു.


When there are no more symbols on the right-hand side, the function returns.

വലതുവശത്ത് കൂടുതൽ ചിഹ്നങ്ങളില്ലെങ്കിൽ, ഫംഗ്ഷൻ തിരികെ നൽകുന്നു.


Figure 3.16 shows pseudo-code for a recursive descent parser.

ചിത്രം 3.16 ഒരു റിcursive descent parser-ൻ്റെ pseudo-code കാണിക്കുന്നു.


We have constructed this program by the following process.

ഇനി പറയുന്ന പ്രക്രിയയിലൂടെയാണ് ഈ പ്രോഗ്രാം നിർമ്മിച്ചിരിക്കുന്നത്.


We have first added a production T' → T$.

ആദ്യം, T' → T$ എന്നൊരു പ്രൊഡക്ഷൻ ചേർത്തു.


For the parseT function, we look at the productions for T.

parseT ഫംഗ്ഷനായി, T-യുടെ പ്രൊഡക്ഷനുകളാണ് നമ്മൾ നോക്കുന്നത്.


Since R is also Nullable, we must choose this production also on symbols in FOLLOW(T).

R-ഉം Nullable ആയതുകൊണ്ട്, FOLLOW(T)-യിലെ ചിഹ്നങ്ങളിലും ഈ പ്രൊഡക്ഷൻ തിരഞ്ഞെടുക്കണം.


The function match takes as argument a symbol.

match എന്ന ഫംഗ്ഷൻ ഒരു ചിഹ്നത്തെ ഒരു ആർഗ്യുമെന്റായി എടുക്കുന്നു.


In table-driven LL(1) parsing, we encode the selection of productions into a table.

ടേബിൾ-ഡ്രിവൺ LL(1) പാർസിംഗിൽ, പ്രൊഡക്ഷനുകളുടെ തിരഞ്ഞെടുക്കൽ ഒരു പട്ടികയിലേക്ക് എൻകോഡ് ചെയ്യുന്നു.


A simple non-recursive program uses this table and a stack to perform the parsing.

ഒരു ലളിതമായ നോൺ-റിcursive പ്രോഗ്രാം ഈ പട്ടികയും ഒരു സ്റ്റാക്കും ഉപയോഗിച്ച് പാർസിംഗ് നടത്തുന്നു.


The table is cross-indexed by nonterminal and terminal.

പട്ടിക നോൺടെർമിനലും ടെർമിനലും ഉപയോഗിച്ച് ക്രോസ്-ഇൻഡെക്സ് ചെയ്തിരിക്കുന്നു.


If the table-entry is empty, we report an error.

പട്ടികാ എൻട്രി ശൂന്യമാണെങ്കിൽ, ഞങ്ങൾ ഒരു പിശക് റിപ്പോർട്ട് ചെയ്യുന്നു.


If not, we pop the nonterminal from the stack.

അല്ലെങ്കിൽ, നോൺടെർമിനലിനെ സ്റ്റാക്കിൽ നിന്ന് പുറത്തെടുക്കുന്നു.


Conflicts may be caused by ambiguous grammars.

അവ്യക്തമായ വ്യാകരണങ്ങൾ കാരണം വൈരുദ്ധ്യങ്ങൾ ഉണ്ടാകാം.


We will in the next section see how we can rewrite this grammar to avoid conflicts.

അടുത്ത ഭാഗത്ത്, വൈരുദ്ധ്യങ്ങൾ ഒഴിവാക്കാൻ ഈ വ്യാകരണം എങ്ങനെ വീണ്ടും എഴുതാമെന്ന് ഞങ്ങൾ കാണും.


Eliminating left-recursion is one of the methods.

ഇടത്-റിcursion ഇല്ലാതാക്കുക എന്നത് ഒരു രീതിയാണ്.


We start by looking at direct left-recursion.

നേരിട്ടുള്ള ഇടത്-റിcursion നോക്കിക്കൊണ്ടാണ് നമ്മൾ ആരംഭിക്കുന്നത്.


At this point, it may stop reading the input or it may attempt continued lexical analysis.

ഈ ഘട്ടത്തിൽ, ഇൻപുട്ട് വായിക്കുന്നത് ഇത് നിർത്തിയേക്കാം അല്ലെങ്കിൽ തുടർച്ചയായ ലെക്സിക്കൽ വിശകലനം നടത്താൻ ശ്രമിച്ചേക്കാം.


The purpose of the latter approach is to try finding further lexical errors in the same input.

തുടർന്നുള്ള സമീപനത്തിന്റെ ലക്ഷ്യം, അതേ ഇൻപുട്ടിൽ കൂടുതൽ ലെക്സിക്കൽ പിശകുകൾ കണ്ടെത്താൻ ശ്രമിക്കുക എന്നതാണ്.


Some of these subsequent errors may, however, not be real errors but may be caused by the lexer not skipping enough characters.

എങ്കിലും, ഈ തുടർച്ചയായ ചില പിശകുകൾ യഥാർത്ഥ പിശകുകൾ ആയിരിക്കണമെന്നില്ല, എന്നാൽ ലെക്സർ ആവശ്യത്തിന് പ്രതീകങ്ങൾ ഒഴിവാക്കാത്തതുകൊണ്ട് സംഭവിക്കാവുന്നതാണ്.


If, for example, the start of a comment is ill-formed, the lexer may try to interpret the contents of the comment as individual tokens.

ഉദാഹരണത്തിന്, ഒരു അഭിപ്രായത്തിന്റെ തുടക്കം ശരിയായി രൂപപ്പെട്ടില്ലെങ്കിൽ, അഭിപ്രായത്തിന്റെ ഉള്ളടക്കം വ്യക്തിഗത ടോക്കണുകളായി വ്യാഖ്യാനിക്കാൻ ലെക്സർ ശ്രമിച്ചേക്കാം.


When the lexer finds an error, the consumer of the tokens that the lexer produces can not usually itself produce a valid result.

ലെക്സർ ഒരു പിശക് കണ്ടെത്തുമ്പോൾ, ലെക്സർ ഉത്പാദിപ്പിക്കുന്ന ടോക്കണുകളുടെ ഉപഭോക്താവിന് സാധാരണയായി സാധുവായ ഒരു ഫലം ഉണ്ടാക്കാൻ കഴിയില്ല.


However, the compiler may try to find other errors in the remaining input, again allowing the user to find several errors in one edit-compile cycle.

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


Nevertheless, such error recovery has, when the input is so large that restarting the lexer from the start of input incurs a considerable time overhead, proven to be an aid in productivity.

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


A lexer generator will typically use a notation for regular expressions similar to the one described in section 2.1.

ഒരു ലെക്സർ ജനറേറ്റർ സാധാരണയായി വിഭാഗം 2.1-ൽ വിവരിച്ചതുപോലെയുള്ള റെഗുലർ എക്സ്പ്രഷനുകൾക്കായി ഒരു രീതി ഉപയോഗിക്കും.


For example, an*intended to match a multiplication symbol in the input is distinguished from an*used to denote repetition by quoting the*symbol, e.g. as ‘*‘.

ഉദാഹരണത്തിന്, ഇൻപുട്ടിലെ ഗുണിത ചിഹ്നവുമായി പൊരുത്തപ്പെടുന്നതിന് ഉദ്ദേശിച്ചുള്ള * ചിഹ്നത്തെ, ആവർത്തനം സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്ന * ചിഹ്നത്തിൽ നിന്ന് വേർതിരിക്കുന്നത്, * ചിഹ്നം ഉദ്ധരിച്ചാണ്, അതായത് ‘*‘.


Additionally, some lexer generators extend regular expressions in various ways, e.g., allowing a set of characters to be specified by listing the characters that are not in the set.

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


The input to the lexer generator will normally contain a list of regular expressions that each denote a token.

ലെക്സർ ജനറേറ്ററിലേക്കുള്ള ഇൻപുട്ടിൽ സാധാരണയായി ഓരോ ടോക്കണിനെയും സൂചിപ്പിക്കുന്ന റെഗുലർ എക്സ്പ്രഷനുകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടാകും.


Each of these regular expressions has an associated action.

ഈ റെഗുലർ എക്സ്പ്രഷനുകളിൽ ഓരോന്നിനും അനുബന്ധമായ ഒരു പ്രവർത്തനം ഉണ്ട്.


The action describes what is passed on to the consumer (e.g., the parser), typically an element from a token data type, which describes the type of token (NUM, ID, etc.) and sometimes additional information such as the value of a number token.

പ്രവർത്തനം ഉപഭോക്താവിന് (ഉദാഹരണത്തിന്, പാർസർ) എന്ത് കൈമാറണം എന്ന് വിവരിക്കുന്നു, സാധാരണയായി ഒരു ടോക്കൺ ഡാറ്റാ ടൈപ്പിൽ നിന്നുള്ള ഒരു ഘടകം, ഇത് ടോക്കണിന്റെ തരം (NUM, ID, തുടങ്ങിയവ) വിവരിക്കുന്നു, ചിലപ്പോൾ ഒരു നമ്പർ ടോക്കണിന്റെ മൂല്യം പോലുള്ള അധിക വിവരങ്ങളും.


Normally, the lexer generator requires white-space and comments to be defined by regular expressions.

സാധാരണയായി, വൈറ്റ്-സ്പേസും, അഭിപ്രായങ്ങളും റെഗുലർ എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് നിർവചിക്കണമെന്ന് ലെക്സർ ജനറേറ്റർ ആവശ്യപ്പെടുന്നു.


An action can be more than just returning a token.

ഒരു ടോക്കൺ തിരികെ നൽകുന്നതിനേക്കാൾ കൂടുതലായി ഒരു പ്രവർത്തനത്തിന് കഴിയും.


If, for example, a language has a large number of keywords, then a DFA that recognises all of these individually can be fairly large.

ഉദാഹരണത്തിന്, ഒരു ഭാഷയ്ക്ക് ധാരാളം കീവേഡുകൾ ഉണ്ടെങ്കിൽ, ഇതെല്ലാം വ്യക്തിഗതമായി തിരിച്ചറിയുന്ന ഒരു DFA വളരെ വലുതായിരിക്കും.


In such cases, the keywords are not described as separate regular expressions in the lexer definition but instead treated as special cases of the identifier token.

അത്തരം സന്ദർഭങ്ങളിൽ, കീവേഡുകൾ ലെക്സർ നിർവചനത്തിൽ പ്രത്യേക റെഗുലർ എക്സ്പ്രഷനുകളായി വിവരിക്കുന്നില്ല, മറിച്ച്, ഐഡന്റിഫയർ ടോക്കണിന്റെ പ്രത്യേക കേസുകളായി കണക്കാക്കുന്നു.


A similar strategy can be used if the language allows identifiers to shadow keywords.

ഒരു ഭാഷ, കീവേഡുകളെ മറയ്ക്കാൻ ഐഡന്റിഫയറുകളെ അനുവദിക്കുകയാണെങ്കിൽ, സമാനമായ ഒരു തന്ത്രം ഉപയോഗിക്കാം.


Another use of non-trivial lexer actions is for nested comments.

നെസ്റ്റഡ് കമന്റുകൾക്കായി, നിസ്സാരമല്ലാത്ത ലെക്സർ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്ന മറ്റൊരു രീതി.


In principle, a regular expression (or finite automaton) cannot recognise arbitrarily nested comments.

തത്വത്തിൽ, ഒരു റെഗുലർ എക്സ്പ്രഷനോ (അല്ലെങ്കിൽ ഫൈനൈറ്റ് ഓട്ടോമാറ്റോ) ഇഷ്ടമുള്ള രീതിയിലുള്ള നെസ്റ്റഡ് കമന്റുകൾ തിരിച്ചറിയാൻ കഴിയില്ല.


Adding the epsilon transitions as arrows in figure 3.26 would produce a very cluttered picture.

ചിത്രം 3.26-ൽ എപ്‌സിലോൺ ട്രാൻസിഷനുകൾ അമ്പടയാളങ്ങളായി ചേർത്താൽ വളരെ ആശയക്കുഴപ്പമുണ്ടാക്കുന്ന ഒരു ചിത്രം ഉണ്ടാകും.


But this is for presentation purposes only: The transi- tions have the same meaning regardless of whether they are shown in the picture of the DFA or in the table.

എന്നാൽ ഇത് അവതരണ ആവശ്യങ്ങൾക്കുള്ളതാണ്: ട്രാൻസിഷനുകൾക്ക് ഒരേ അർത്ഥമാണുള്ളത്, അത് DFA-യുടെ ചിത്രത്തിലോ പട്ടികയിലോ കാണിച്ചിരിക്കുന്നു എന്നത് പരിഗണിക്കാതെ.


Together with these epsilon-transitions, the NFAs in figure 3.26 form a single, combined NFA.

ഈ എപ്‌സിലോൺ-ട്രാൻസിഷനുകളോടൊപ്പം, ചിത്രം 3.26-ലെ NFAs ഒരുമിച്ച് ചേർന്ന് ഒരൊറ്റ, സംയോജിത NFA ഉണ്ടാക്കുന്നു.


This NFA has the starting state A (the starting state of the NFA for the added start production) and an accepting state for each production in the grammar.

ഈ NFA-യ്ക്ക് ആരംഭ അവസ്ഥ A (ചേർത്ത ആരംഭ ഉൽപാദനത്തിനായുള്ള NFA-യുടെ ആരംഭ അവസ്ഥ) ഉണ്ട്, കൂടാതെ വ്യാകരണത്തിലെ ഓരോ ഉൽപാദനത്തിനും ഒരു സ്വീകാര്യമായ അവസ്ഥയുമുണ്ട്.


We must now convert this NFA into a DFA using the subset construc- tion shown in section 2.5.

നമ്മൾ ഇപ്പോൾ ഈ NFA-യെ, 2.5-ാം ഭാഗത്ത് കാണിച്ചിരിക്കുന്ന ഉപസെറ്റ് നിർമ്മാണം ഉപയോഗിച്ച് ഒരു DFA-ആയി മാറ്റണം.


Instead of showing the resulting DFA graphically, we construct a table where transitions on terminals are shown as shift actions and transitions on nonterminals as go actions.

ഗ്രാഫിക്കായി DFA കാണിക്കുന്നതിനുപകരം, ടെർമിനലുകളിലെ ട്രാൻസിഷനുകൾ ഷിഫ്റ്റ് പ്രവർത്തനങ്ങളായും നോൺ-ടെർമിനലുകളിലെ ട്രാൻസിഷനുകൾ ഗോ പ്രവർത്തനങ്ങളായും കാണിക്കുന്ന ഒരു പട്ടിക നമ്മൾ ഉണ്ടാക്കുന്നു.


Figure 3.28 shows the DFA constructed from the NFA made by adding epsilon-transitions in 3.27 to figure 3.26.

ചിത്രം 3.26-ലേക്ക് 3.27-ൽ എപ്‌സിലോൺ-ട്രാൻസിഷനുകൾ ചേർത്ത് ഉണ്ടാക്കിയ NFA-യിൽ നിന്ന് നിർമ്മിച്ച DFA ചിത്രം 3.28-ൽ കാണിക്കുന്നു.


The sets of NFA states that form each DFA state is shown in the second column of the table in figure 3.28.

ഓരോ DFA അവസ്ഥയും രൂപീകരിക്കുന്ന NFA അവസ്ഥകളുടെ കൂട്ടം ചിത്രം 3.28-ലെ പട്ടികയുടെ രണ്ടാം സ്തംഭത്തിൽ കാണിച്ചിരിക്കുന്നു.


We will need these below for adding reduce and accept actions, but once this is done, we will not need them anymore, so we can remove them from the final table.

reduce, accept പ്രവർത്തനങ്ങൾ ചേർക്കുന്നതിന് ഇത് താഴെ ആവശ്യമാണ്, എന്നാൽ ഇത് ചെയ്തു കഴിഞ്ഞാൽ, ഇത് ഇനി ആവശ്യമില്ല, അതിനാൽ നമുക്ക് ഇത് അവസാന പട്ടികയിൽ നിന്ന് നീക്കം ചെയ്യാം.


To add reduce and accept actions, we first need to compute the FOLLOW sets for each nonterminal, as described in section 3.10.

reduce, accept പ്രവർത്തനങ്ങൾ ചേർക്കുന്നതിന്, നമ്മൾ ആദ്യം ഓരോ നോൺ‌ടെർമിനലിനുമുള്ള FOLLOW സെറ്റുകൾ കണക്കാക്കണം, ഇത് 3.10-ാം ഭാഗത്ത് വിവരിക്കുന്നു.


For purpose of calculating FOLLOW, we add yet another extra start production: T ′′ → T ′ $, to handle end-of-text conditions as described in section 3.10.

FOLLOW കണക്കാക്കുന്നതിന്, നമ്മൾ മറ്റൊന്ന് അധികമായി ചേർക്കുന്നു: T ′′ → T ′ $, 3.10-ാം ഭാഗത്ത് വിവരിച്ചതുപോലെ ടെക്സ്റ്റിൻ്റെ അവസാനം കൈകാര്യം ചെയ്യാൻ.


This gives us the following result: FOLLOW(T ′ ) ={$} FOLLOW(T) ={c,$} FOLLOW(R) ={c,$}

ഇത് നമുക്ക് താഴെ പറയുന്ന ഫലം നൽകുന്നു: FOLLOW(T ′ ) ={$} FOLLOW(T) ={c,$} FOLLOW(R) ={c,$}


We then add reduce actions by the following rule: If a DFA states contains the accepting NFA state for a production p: N→α, we add reduce p as action to son 94CHAPTER 3. SYNTAX ANALYSIS DFANFATransitions statestatesa b cTR 0A, C, E, I, Js3s4g1g2 1B 2D 3F, C, E, I, Js3s4g5g2 4K, I, Js4g6 5Gs7 6L 7H Figure 3.28: SLR DFA for grammar 3.9 all symbols in FOLLOW(N).

തുടർന്ന്, താഴെ പറയുന്ന നിയമം അനുസരിച്ച് reduce പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു: ഒരു DFA അവസ്ഥയിൽ p: N→α എന്ന ഉൽപാദനത്തിനായുള്ള സ്വീകാര്യമായ NFA അവസ്ഥ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, FOLLOW(N)-ലെ എല്ലാ ചിഹ്നങ്ങളിലും reduce p എന്ന പ്രവർത്തനം ചേർക്കുന്നു.


Reduction on production 0 (the extra start production that was added before constructing the NFA) is written as accept.

ഉൽപാദനം 0-ൽ (NFA നിർമ്മിക്കുന്നതിന് മുമ്പ് ചേർത്ത അധിക ആരംഭ ഉൽപാദനം) കുറയ്ക്കൽ സ്വീകരിക്കുക (accept) എന്ന് എഴുതുന്നു.


In figure 3.28, state 0 contains NFA state I, which accepts production 3.

ചിത്രം 3.28-ൽ, അവസ്ഥ 0-ൽ NFA അവസ്ഥ I ഉണ്ട്, ഇത് ഉൽപാദനം 3 സ്വീകരിക്കുന്നു.


Hence, we add r3 as actions at the symbols c and $ (as these are in FOLLOW(R)).

അതുകൊണ്ട്, c, $ എന്നീ ചിഹ്നങ്ങളിൽ r3 പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു (എന്തെന്നാൽ ഇവ FOLLOW(R)-ൽ ഉണ്ട്).


State 1 contains NFA state B, which accepts production 0.

അവസ്ഥ 1-ൽ NFA അവസ്ഥ B ഉണ്ട്, ഇത് ഉൽപാദനം 0 സ്വീകരിക്കുന്നു.


We add this at the symbol $ (FOLLOW(T ′ )).

നമ്മൾ ഇത് $ എന്ന ചിഹ്നത്തിൽ ചേർക്കുന്നു (FOLLOW(T ′ )).


As noted above, this is written as accept (abbreviated to “a”).

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ഇത് സ്വീകരിക്കുക (a എന്ന് ചുരുക്കി എഴുതുന്നു).


In the same way, we add reduce actions to state 3, 4, 6 and 7.

അതുപോലെ, അവസ്ഥ 3, 4, 6, 7 എന്നിവയിലേക്ക് reduce പ്രവർത്തനങ്ങൾ ചേർക്കുന്നു.


The compiler uses intermediate code as a stepping stone.

കംപൈലർ ഒരു സ്റ്റെപ്പിംഗ് സ്റ്റോണായി ഇന്റർമീഡിയറ്റ് കോഡ് ഉപയോഗിക്കുന്നു.


Type checking is a crucial phase in the compilation process.

കംപൈലേഷൻ പ്രക്രിയയിലെ ഒരു പ്രധാന ഘട്ടമാണ് ടൈപ്പ് പരിശോധന.


The program needs to be expressed as machine code.

പ്രോഗ്രാം മെഷീൻ കോഡായി പ്രകടിപ്പിക്കേണ്ടതുണ്ട്.


ഇതൊരു സ്ഥിരമായി ടൈപ്പ് ചെയ്ത ഭാഷയാണ്.


The interpreter will check if the strings contain digits.

സ്ട്രിംഗുകളിൽ അക്കങ്ങൾ ഉണ്ടോയെന്ന് ഇന്റർപ്രെറ്റർ പരിശോധിക്കും.


Javascript performs a dynamic check and conversion.

ജാവ സ്ക്രിപ്റ്റ് ഒരു ഡൈനാമിക് പരിശോധനയും പരിവർത്തനവും നടത്തുന്നു.


The language silently does something that probably makes no sense.

ഭാഷ, ഒരുപക്ഷേ അർത്ഥമില്ലാത്ത ഒന്ന് രഹസ്യമായി ചെയ്യുന്നു.


The checking phase operates on the abstract syntax tree.

പരിശോധനാ ഘട്ടം അമൂർത്തമായ സിന്റാക്സ് ട്രീയിൽ പ്രവർത്തിക്കുന്നു.


Such information is often called attributes of the syntax tree.

അത്തരം വിവരങ്ങളെ പലപ്പോഴും സിന്റാക്സ് ട്രീയുടെ ആട്രിബ്യൂട്ടുകൾ എന്ന് വിളിക്കുന്നു.


Synthesized attributes are passed upwards in the syntax tree.

സിന്തസൈസ് ചെയ്ത ആട്രിബ്യൂട്ടുകൾ സിന്റാക്സ് ട്രീയിൽ മുകളിലേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു.


Inherited attributes are passed downwards in the syntax tree.

പാരമ്പര്യ ആട്രിബ്യൂട്ടുകൾ സിന്റാക്സ് ട്രീയിൽ താഴേക്ക് കൈമാറ്റം ചെയ്യപ്പെടുന്നു.


ഇതിനൊരു ഉദാഹരണമാണ് ചിഹ്ന പട്ടിക.


We will focus on type checking in this chapter.

ഈ അധ്യായത്തിൽ ഞങ്ങൾ ടൈപ്പ് പരിശോധനയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.


We need symbol tables that bind variables and functions.

വേരിയബിളുകളും ഫംഗ്ഷനുകളും ബന്ധിപ്പിക്കുന്ന ചിഹ്ന പട്ടികകൾ നമുക്ക് ആവശ്യമാണ്.


A variable is bound to one of the two types int or bool.

ഒരു വേരിയബിൾ int അല്ലെങ്കിൽ bool എന്നീ രണ്ട് തരങ്ങളിൽ ഒന്നിലേക്ക് ബന്ധിപ്പിക്കപ്പെട്ടിരിക്കുന്നു.


Function types are written as a parenthesized list.

ഫംഗ്ഷൻ തരങ്ങൾ ഒരു പരാന്തസിസ് ചെയ്ത ലിസ്റ്റായി എഴുതപ്പെടുന്നു.


We will assume that symbol tables are persistent.

ചിഹ്ന പട്ടികകൾ നിലനിൽക്കുന്നതാണെന്ന് ഞങ്ങൾ അനുമാനിക്കും.


When we type check expressions, the symbol tables are inherited attributes.

എക്സ്പ്രഷനുകൾ ടൈപ്പ് ചെയ്യുമ്പോൾ, ചിഹ്ന പട്ടികകൾ പാരമ്പര്യ ആട്രിബ്യൂട്ടുകളാണ്.


The type of the expression is returned as a synthesized attribute.

എക്സ്പ്രഷൻ്റെ തരം ഒരു സിന്തസൈസ്ഡ് ആട്രിബ്യൂട്ടായി തിരികെ നൽകുന്നു.


ഫംഗ്ഷൻ ഒരു ടൈപ്പ് പിശക് റിപ്പോർട്ട് ചെയ്യുന്നു.


Context-free languages are capable of such counting, essentially using the stack for this purpose.

സന്ദർഭോചിത ഭാഷകൾക്ക് അത്തരം എണ്ണൽ നടത്താൻ കഴിയും, പ്രധാനമായും ഇതിനായി സ്റ്റാക്ക് ഉപയോഗിക്കുന്നു.


Even so, there are limitations: A context-free language can only keep count of one thing at a time.

എങ്കിലും, പരിമിതികളുണ്ട്: ഒരു സന്ദർഭോചിത ഭാഷയ്ക്ക് ഒരേ സമയം ഒരൊറ്റ കാര്യം മാത്രമേ എണ്ണാൻ കഴിയൂ.


Context-free languages are, as regular languages, closed under union.

സാധാരണ ഭാഷകളെപ്പോലെ, സന്ദർഭോചിത ഭാഷകളും യൂണിയനിൽ അടച്ചിരിക്കുന്നു.


Context-free languages are also closed under prefix, suffix, subsequence and reversal.

സന്ദർഭോചിത ഭാഷകൾ പ്രിഫിക്സ്, സഫിക്സ്, ഉപ-അനുക്രമം, വിപരീതം എന്നിവയിലും അടച്ചിരിക്കുന്നു.


However, context-free languages are not closed under intersection or complement.

എങ്കിലും, സന്ദർഭോചിത ഭാഷകൾ ഇന്റർസെക്ഷനിലോ കോംപ്ലിമെന്റിലോ അടച്ചിട്ടില്ല.


Context-free grammars were first proposed as a notation for describing natural languages.

പ്രകൃതിദത്ത ഭാഷകൾ വിവരിക്കുന്നതിനുള്ള ഒരു രീതി എന്ന നിലയിലാണ് സന്ദർഭോചിത വ്യാകരണങ്ങൾ ആദ്യമായി നിർദ്ദേശിക്കപ്പെട്ടത്.


The qualifier “context-free” distinguishes this notation from the other two grammar notations.

“സന്ദർഭോചിതം” എന്ന വിശേഷണം ഈ രീതിയെ മറ്റ് രണ്ട് വ്യാകരണ രീതികളിൽ നിന്ന് വേർതിരിക്കുന്നു.


In context-free grammars, derivation of a nonterminal is independent of the context.

സന്ദർഭോചിത വ്യാകരണങ്ങളിൽ, ഒരു നോൺടെർമിനലിന്റെ ഉത്ഭവം സന്ദർഭത്തെ ആശ്രയിക്കുന്നില്ല.


Context-free grammars are actually too weak to describe natural languages.

സന്ദർഭോചിത വ്യാകരണങ്ങൾ യഥാർത്ഥത്തിൽ പ്രകൃതിദത്ത ഭാഷകൾ വിവരിക്കാൻ വളരെ ദുർബലമാണ്.


Since then, variants of this notation has been used for defining or describing almost all programming languages.

അതിനുശേഷം, ഈ രീതിയുടെ വകഭേദങ്ങൾ മിക്കവാറും എല്ലാ പ്രോഗ്രാമിംഗ് ഭാഷകളും നിർവചിക്കാനും വിവരിക്കാനും ഉപയോഗിച്ചിട്ടുണ്ട്.


Most parser generators are based on LALR(1) parsing, but a few use LL(1) parsing.

മിക്കവാറും പാർസർ ജനറേറ്ററുകളും LALR(1) പാർസിംഗിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, എന്നാൽ ചിലത് LL(1) പാർസിംഗ് ഉപയോഗിക്കുന്നു.


The Dragon Book tells more about parsing methods than the present book.

ഡ്രാഗൺ ബുക്ക് ഈ പുസ്തകത്തേക്കാൾ കൂടുതൽ പാർസിംഗ് രീതികളെക്കുറിച്ച് പറയുന്നു.


Draw a third, different syntax tree for aabbbcc using the same grammar.

അതേ വ്യാകരണം ഉപയോഗിച്ച് aabbbcc എന്നതിനായുള്ള മൂന്നാമത്തെ വ്യത്യസ്ത സിന്റാക്സ് ട്രീ വരയ്ക്കുക.


Write an unambiguous grammar for the language of balanced parentheses.

തുല്യമായ ബ്രാക്കറ്റുകളുടെ ഭാഷയ്ക്കായി അവ്യക്തമല്ലാത്ത ഒരു വ്യാകരണം എഴുതുക.


Write grammars for each of the following languages.

ഇനി പറയുന്ന ഓരോ ഭാഷകൾക്കും വ്യാകരണങ്ങൾ എഴുതുക.


An important concept in programming languages is the ability to name objects.

പ്രോഗ്രാമിംഗ് ഭാഷകളിലെ ഒരു പ്രധാന ആശയം വസ്തുക്കൾക്ക് പേര് നൽകാനുള്ള കഴിവാണ്.


Each such named object will have a declaration, where the name is defined as a synonym for the object.

അത്തരം ഓരോ പേരുള്ള ഒബ്ജക്റ്റിനും ഒരു പ്രഖ്യാപനം ഉണ്ടാകും, അവിടെ പേര് ഒബ്ജക്റ്റിന്റെ പര്യായമായി നിർവചിക്കപ്പെടുന്നു.


Each name will also have a number of uses, where the name is used as a reference to the object.

ഓരോ പേരിനും നിരവധി ഉപയോഗങ്ങൾ ഉണ്ടാകും, അവിടെ പേര് ഒബ്ജക്റ്റിലേക്കുള്ള ഒരു റഫറൻസായി ഉപയോഗിക്കുന്നു.


Often, the declaration of a name has a limited scope.

പലപ്പോഴും, ഒരു പേരിന്റെ പ്രഖ്യാപനത്തിന് പരിമിതമായ സ്കോപ്പ് ഉണ്ട്.


A compiler will need to keep track of names and the objects these are bound to.

ഒരു കംപൈലറിന് പേരുകളും അവ ബന്ധിപ്പിച്ചിട്ടുള്ള ഒബ്ജക്റ്റുകളും ട്രാക്ക് ചെയ്യേണ്ടതുണ്ട്.


The simplest way to execute a program is interpretation.

ഒരു പ്രോഗ്രാം നടപ്പിലാക്കാനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം വ്യാഖ്യാനമാണ്.


Interpretation is done by a program called an interpreter.

ഒരു ഇന്റർപ്രെറ്റർ എന്ന് വിളിക്കപ്പെടുന്ന ഒരു പ്രോഗ്രാം വഴിയാണ് വ്യാഖ്യാനം ചെയ്യുന്നത്.


This is similar to how a human evaluates a mathematical expression.

ഒരു മനുഷ്യൻ ഒരു ഗണിതശാസ്ത്രപരമായ പദപ്രയോഗം വിലയിരുത്തുന്നതിന് ഇത് സമാനമാണ്.


We insert the values of variables in the expression and evaluate it bit by bit.

പദപ്രയോഗത്തിലെ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ ചേർക്കുകയും ഓരോ ഭാഗങ്ങളായി വിലയിരുത്തുകയും ചെയ്യുന്നു.


An interpreter will keep the formula unchanged and use a symbol table.

ഒരു ഇന്റർപ്രെറ്റർ ഫോർമുല മാറ്റമില്ലാതെ സൂക്ഷിക്കുകയും ഒരു ചിഹ്ന പട്ടിക ഉപയോഗിക്കുകയും ചെയ്യും.


The interpreter is a function that takes an abstract syntax tree and a symbol table.

ഒരു അമൂർത്തമായ സിന്റാക്സ് ട്രീയും ഒരു ചിഹ്ന പട്ടികയും എടുക്കുന്ന ഒരു ഫംഗ്ഷനാണ് ഇന്റർപ്രെറ്റർ.


The function can call itself recursively on parts of the abstract syntax tree.

അമൂർത്തമായ സിന്റാക്സ് ട്രീയുടെ ഭാഗങ്ങളിൽ ഫംഗ്ഷന് സ്വയം ആവർത്തിച്ച് വിളിക്കാൻ കഴിയും.


This process can be extended to also handle statements and declarations.

ഈ പ്രക്രിയ പ്രസ്താവനകളും പ്രഖ്യാപനങ്ങളും കൈകാര്യം ചെയ്യുന്നതിനായി വികസിപ്പിക്കാൻ കഴിയും.


Some input and output may be done as side effects by the interpreter.

ചില ഇൻപുട്ടും ഔട്ട്‌പുട്ടും ഇന്റർപ്രെറ്റർ വഴി സൈഡ് ഇഫക്റ്റുകളായി ചെയ്യാവുന്നതാണ്.


We will in this chapter assume that the symbol tables are persistent.

ഈ അധ്യായത്തിൽ, ചിഹ്ന പട്ടികകൾ നിലനിൽക്കുന്നതാണെന്ന് ഞങ്ങൾ അനുമാനിക്കും.


An intepreter will typically consist of one function per syntactic category.

ഒരു ഇന്റർപ്രെറ്റർ സാധാരണയായി ഓരോ ശൈലീ വിഭാഗത്തിനും ഓരോ ഫംഗ്ഷൻ ഉൾക്കൊള്ളുന്നു.


Each function will take as arguments an abstract syntax tree.

ഓരോ ഫംഗ്ഷനും ഒരു അമൂർത്തമായ സിന്റാക്സ് ട്രീ ആർഗ്യുമെന്റുകളായി എടുക്കും.


We will use a small (somewhat contrived) language to show the principles.

തത്വങ്ങൾ കാണിക്കാൻ ഞങ്ങൾ ചെറുതും (അൽപ്പം കൃത്രിമവുമായ) ഒരു ഭാഷ ഉപയോഗിക്കും.


വ്യാകരണം 5.1-ൽ ഇതിന്റെ ശൈലി നൽകിയിരിക്കുന്നു.


The functions are all mutually recursive.

എല്ലാ ഫംഗ്ഷനുകളും പരസ്പരം ആവർത്തനപരമാണ്.


Each function declares its result type and the types and names of its arguments.

ഓരോ ഫംഗ്ഷനും അതിന്റെ ഫലത്തിന്റെ തരവും, ആർഗ്യുമെന്റുകളുടെ തരവും, പേരുകളും പ്രഖ്യാപിക്കുന്നു.


A program must contain a function called main.

ഒരു പ്രോഗ്രാമിൽ മെയിൻ എന്ന് പേരുള്ള ഒരു ഫംഗ്ഷൻ ഉണ്ടായിരിക്കണം.


Execution of the program is by calling this function with the input.

പ്രോഗ്രാം നടപ്പിലാക്കുന്നത് ഇൻപുട്ട് ഉപയോഗിച്ച് ഈ ഫംഗ്ഷൻ വിളിക്കുന്നതിലൂടെയാണ്.


The result of this function call is the output of the program.

ഈ ഫംഗ്ഷൻ കോളിന്റെ ഫലം പ്രോഗ്രാമിന്റെ ഔട്ട്‌പുട്ടാണ്.


An interpreter for this language must take the abstract syntax tree of the program.

ഈ ഭാഷയുടെ ഒരു ഇന്റർപ്രെറ്റർ പ്രോഗ്രാമിന്റെ അമൂർത്തമായ സിന്റാക്സ് ട്രീ എടുക്കണം.


If translation is done directly, the number of compilers is equal to the product of the number of languages and the number of machines.

നേരിട്ടുള്ള വിവർത്തനം ചെയ്യുകയാണെങ്കിൽ, കംപൈലറുകളുടെ എണ്ണം ഭാഷകളുടെയും മെഷീനുകളുടെയും എണ്ണത്തിന്റെ ഗുണനഫലത്തിന് തുല്യമായിരിക്കും.


If a common intermediate language is used, one front-end is needed for every language and one back-end is needed for each machine.

ഒരു പൊതുവായ ഇടനില ഭാഷ ഉപയോഗിക്കുകയാണെങ്കിൽ, എല്ലാ ഭാഷയ്ക്കും ഒരൊറ്റ ഫ്രണ്ട്-എൻഡും, ഓരോ മെഷീനും ഓരോ ബാക്ക്-എൻഡും ആവശ്യമാണ്.


This way, there is no need to write a separate back-end for each machine.

ഈ രീതിയിൽ, ഓരോ മെഷീനും പ്രത്യേകം ബാക്ക്-എൻഡ് എഴുതേണ്ടതില്ല.


A compiled program can be distributed in a single intermediate form for all machines.

കംപൈൽ ചെയ്ത ഒരു പ്രോഗ്രാം എല്ലാ മെഷീനുകൾക്കും ഒരൊറ്റ ഇടനില രൂപത്തിൽ വിതരണം ചെയ്യാവുന്നതാണ്.


Interpreting the intermediate form will in most cases be a lot slower than executing translated code directly.

ഇടനില രൂപം വ്യാഖ്യാനിക്കുന്നത്, വിവർത്തനം ചെയ്ത കോഡ് നേരിട്ട് എക്സിക്യൂട്ട് ചെയ്യുന്നതിനേക്കാൾ വളരെ സാവധാനത്തിലായിരിക്കും.


Nevertheless, the approach has seen some success, e.g., with Java.

എങ്കിലും, ഈ സമീപനം ചില വിജയങ്ങൾ കണ്ടിട്ടുണ്ട്, ഉദാഹരണത്തിന്, ജാവയിൽ.


Some of the speed penalty can be eliminated by translating the intermediate code to machine code immediately before or during execution of the program.

പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുന്നതിന് തൊട്ടുമുന്‍പോ, അല്ലെങ്കിൽ ചെയ്യുന്ന സമയത്തോ, ഇടനില കോഡിനെ മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നതിലൂടെ വേഗത കുറയ്ക്കാൻ കഴിയും.


An intermediate language should, ideally, have the following properties.

ഒരു ഇടനില ഭാഷയ്ക്ക്, ആത്യന്തികമായി, താഴെ പറയുന്ന ഗുണങ്ങൾ ഉണ്ടായിരിക്കണം.


It should be easy to translate from a high-level language to the intermediate language.

ഒരു ഉയർന്ന തലത്തിലുള്ള ഭാഷയിൽ നിന്ന് ഇടനില ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുന്നത് എളുപ്പമായിരിക്കണം.


It should be easy to translate from the intermediate language to machine code.

ഇടനില ഭാഷയിൽ നിന്ന് മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നത് എളുപ്പമായിരിക്കണം.


The intermediate format should be suitable for optimisations.

ഇടനില ഫോർമാറ്റ് ഒപ്റ്റിമൈസേഷനുകൾക്ക് അനുയോജ്യമായിരിക്കണം.


A solution that may reduce the translation burden, though it does not address the other problems, is to have two intermediate levels.

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


When the intermediate format is shared between many compilers, it makes sense to do as many optimisations as possible on the intermediate format.

ഇടനില ഫോർമാറ്റ് നിരവധി കംപൈലറുകൾക്കിടയിൽ പങ്കിടുമ്പോൾ, ഇടനില ഫോർമാറ്റിൽ കഴിയുന്നത്ര ഒപ്റ്റിമൈസേഷനുകൾ ചെയ്യുന്നത് അർത്ഥവത്താണ്.


Another thing to consider when choosing an intermediate language is the “granularity”.

ഒരു ഇടനില ഭാഷ തിരഞ്ഞെടുക്കുമ്പോൾ പരിഗണിക്കേണ്ട മറ്റൊരു കാര്യം “ഗ്രാനുലാരിറ്റി” ആണ്.


Should an operation in the intermediate language correspond to a large amount of work or to a small amount of work?

ഇടനില ഭാഷയിലെ ഒരു പ്രവർത്തനം വലിയ അളവിലുള്ള ജോലിയുമായി ബന്ധപ്പെട്ടിരിക്കണമോ അതോ ചെറിയ അളവിലുള്ള ജോലിയുമായി ബന്ധപ്പെട്ടിരിക്കണമോ?


The first of these approaches is often used when the intermediate language is interpreted.

ഈ സമീപനങ്ങളിൽ ആദ്യത്തേത് പലപ്പോഴും ഇടനില ഭാഷ വ്യാഖ്യാനിക്കുമ്പോൾ ഉപയോഗിക്കുന്നു.


The opposite approach is to let each intermediate-code operation be as small as possible.

നേരെ മറിച്ചുള്ള സമീപനം, ഓരോ ഇടനില കോഡ് പ്രവർത്തനവും കഴിയുന്നത്ര ചെറുതാക്കുക എന്നതാണ്.


We will generate code using translation functions for each syntactic category.

ഓരോ ശൈലീ വിഭാഗത്തിനും വിവർത്തന ഫംഗ്ഷനുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ കോഡ് ഉണ്ടാക്കും.


Since the translation closely follows the syntactic structure of the program, it is called syntax-directed translation.

വിവർത്തനം പ്രോഗ്രാമിന്റെ ശൈലീപരമായ ഘടനയെ അടുത്തടുത്ത് പിന്തുടരുന്നതിനാൽ, ഇതിനെ സിന്റാക്സ്-നിർദ്ദേശിത വിവർത്തനം എന്ന് വിളിക്കുന്നു.


We will try to remedy this in later chapters by using various optimisation techniques.

വിവിധ ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ ഉപയോഗിച്ച്, വരുന്ന അധ്യായങ്ങളിൽ ഇത് പരിഹരിക്കാൻ ഞങ്ങൾ ശ്രമിക്കും.


The compiler allocates memory for variables.

കമ്പ്യൂട്ടർ വേരിയബിളുകൾക്കായി മെമ്മറി അനുവദിക്കുന്നു.


Arrays can be allocated statically or dynamically.

അറേകൾക്ക് സ്ഥിരമായോ അല്ലെങ്കിൽ ചലനാത്മകമായോ മെമ്മറി അനുവദിക്കാൻ കഴിയും.


The base address of the array is a compile-time constant.

അറേയുടെ അടിസ്ഥാന വിലാസം ഒരു കംപൈൽ-ടൈം സ്ഥിരമാണ്.


Dynamic allocation can be done in several ways.

ചലനാത്മകമായ മെമ്മറി വിതരണം പല രീതിയിൽ ചെയ്യാം.


We will briefly discuss how such can be implemented.

അവ എങ്ങനെ നടപ്പിലാക്കാമെന്ന് നമുക്ക് ചുരുക്കി ചർച്ച ചെയ്യാം.


ലേബലുകൾ ഒരു ചിഹ്ന പട്ടികയിൽ സംഭരിച്ചിരിക്കുന്നു.


A jump to a label will generate a GOTO statement.

ഒരു ലേബലിലേക്കുള്ള ജമ്പ് ഒരു GOTO പ്രസ്താവന ഉണ്ടാക്കും.


The scope of labels can be controlled by the symbol table.

ലേബലുകളുടെ പരിധി ചിഹ്ന പട്ടിക ഉപയോഗിച്ച് നിയന്ത്രിക്കാൻ കഴിയും.


Some languages allow exiting loops from the middle.

ചില ഭാഷകൾക്ക് ലൂപ്പുകളിൽ നിന്ന് നടുവിൽ നിന്ന് പുറത്തുകടക്കാൻ കഴിയും.


We will now look at how these can be translated.

ഇവ എങ്ങനെ വിവർത്തനം ചെയ്യാമെന്ന് നമുക്ക് നോക്കാം.


Floating-point values are stored in different registers.

ഫ്ലോട്ടിംഗ്-പോയിന്റ് മൂല്യങ്ങൾ വ്യത്യസ്ത രജിസ്റ്ററുകളിൽ സംഭരിക്കുന്നു.


We extend our example language with one-dimensional arrays.

ഏകമാന അറേകൾ ഉപയോഗിച്ച് നമ്മുടെ ഉദാഹരണ ഭാഷ വികസിപ്പിക്കുന്നു.


Arrays can be allocated statically, i.e., at compile-time, or dynamically.

അറേകൾക്ക് സ്ഥിരമായി, അതായത്, കംപൈൽ-ടൈമിൽ അല്ലെങ്കിൽ ചലനാത്മകമായി മെമ്മറി നൽകാം.


The index used to access array elements must be multiplied by the size of the elements.

അറേ ഘടകങ്ങൾ ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന സൂചിക, ഘടകങ്ങളുടെ വലുപ്പവുമായി ഗുണിക്കണം.


Dynamic allocation can also be done globally.

ചലനാത്മകമായ മെമ്മറി വിതരണം ലോകവ്യാപകമായി ചെയ്യാനും കഴിയും.


Multi-dimensional arrays can be laid out in memory in two ways.

ബഹു-മാന അറേകൾ രണ്ട് രീതിയിൽ മെമ്മറിയിൽ സ്ഥാപിക്കാൻ കഴിയും.


In row-major form, the array is laid out one row at a time.

വരി-പ്രധാന രൂപത്തിൽ, അറേ ഒരെ സമയം ഒരു വരിയായി സ്ഥാപിച്ചിരിക്കുന്നു.


We extend the grammar for array-elements to accommodate multi-dimensional arrays.

ബഹു-മാന അറേകളെ ഉൾക്കൊള്ളാൻ ഞങ്ങൾ അറേ-ഘടകങ്ങൾക്കായുള്ള വ്യാകരണം വികസിപ്പിക്കുന്നു.


Index checks are fairly easy to generate.

സൂചിക പരിശോധനകൾ ഉണ്ടാക്കാൻ എളുപ്പമാണ്.


Strings are usually implemented in a fashion similar to one-dimensional arrays.

സ്ട്രിംഗുകൾ സാധാരണയായി ഏകമാന അറേകളോട് സാമ്യമുള്ള രീതിയിലാണ് നടപ്പിലാക്കുന്നത്.


The algorithm efficiently sorts the data.

അൽഗോരിതം ഡാറ്റയെ കാര്യക്ഷമമായി അടുക്കുന്നു.


Please provide the necessary documentation.

ആവശ്യമായ രേഖകൾ നൽകുക.


The company announced a new product launch.

കമ്പനി പുതിയ ഉൽപ്പന്നം പുറത്തിറക്കുന്നതായി പ്രഖ്യാപിച്ചു.


He is a highly skilled software engineer.

അദ്ദേഹം വളരെ കഴിവുള്ള ഒരു സോഫ്റ്റ്‌വെയർ എഞ്ചിനീയറാണ്.


The weather forecast predicts heavy rainfall.

കാലാവസ്ഥാ പ്രവചനം കനത്ത മഴയുടെ സൂചന നൽകുന്നു.


ഒന്ന് ആവർത്തിക്കാമോ?


The research paper explores complex topics.

ഗവേഷണ പ്രബന്ധം സങ്കീർണ്ണമായ വിഷയങ്ങൾ ചർച്ച ചെയ്യുന്നു.


She enjoys reading novels in her free time.

അവൾ ഒഴിവുസമയങ്ങളിൽ നോവലുകൾ വായിക്കാൻ ഇഷ്ടപ്പെടുന്നു.


The system requires frequent updates to function properly.

കൃത്യമായി പ്രവർത്തിക്കാൻ സിസ്റ്റത്തിന് പതിവായ അപ്‌ഡേറ്റുകൾ ആവശ്യമാണ്.


The government is implementing new policies.

സർക്കാർ പുതിയ നയങ്ങൾ നടപ്പാക്കുകയാണ്.


The data analysis revealed significant trends.

ഡാറ്റാ വിശകലനം പ്രധാനപ്പെട്ട പ്രവണതകൾ വെളിപ്പെടുത്തി.


നിങ്ങളെ കണ്ടതിൽ എനിക്ക് വളരെ സന്തോഷമുണ്ട്.


പ്രോജക്റ്റ് ചില വെല്ലുവിളികൾ നേരിടുന്നു.


സമ്മേളനം അടുത്ത മാസം നടക്കും.


The technology has revolutionized the industry.

സാങ്കേതികവിദ്യ വ്യവസായത്തിൽ വിപ്ലവം സൃഷ്ടിച്ചു.


അദ്ദേഹം ഒരു പ്രശസ്ത എഴുത്തുകാരനാണ്.


The economic situation is improving gradually.

സാമ്പത്തിക സ്ഥിതി ക്രമേണ മെച്ചപ്പെടുന്നു.


The software update includes new features.

സോഫ്റ്റ്‌വെയർ അപ്‌ഡേറ്റിൽ പുതിയ ഫീച്ചറുകൾ ഉൾപ്പെടുന്നു.


അവൾ ഒരു കഴിവുള്ള സംഗീതജ്ഞയാണ്.


The company is expanding its operations globally.

കമ്പനി അതിന്റെ പ്രവർത്തനങ്ങൾ ലോകമെമ്പാടും വികസിപ്പിക്കുന്നു.


The compiler ensures symbol tables contain necessary information for translation.

പരിഭാഷയ്ക്കായി ആവശ്യമായ വിവരങ്ങൾ ചിഹ്ന പട്ടികകളിൽ ഉണ്ടാകുമെന്ന് കംപൈലർ ഉറപ്പാക്കുന്നു.


When a variable is declared, the compiler stores information in the symbol table.

ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുമ്പോൾ, കംപൈലർ വിവരങ്ങൾ ചിഹ്ന പട്ടികയിൽ സൂക്ഷിക്കുന്നു.


For integer variables, the symbol table holds the intermediate-language variable.

പൂർണ്ണസംഖ്യാ വേരിയബിളുകൾക്കായി, ചിഹ്ന പട്ടികയിൽ ഇടത്തരം ഭാഷാ വേരിയബിൾ ഉണ്ടാകും.


Array variables require base address and dimensions in the symbol table.

അറേ വേരിയബിളുകൾക്ക് ചിഹ്ന പട്ടികയിൽ അടിസ്ഥാന വിലാസവും അളവുകളും ആവശ്യമാണ്.


Records need field offsets and total size information in the symbol table.

Record-കൾക്ക് ഫീൽഡ് ഓഫ്‌സെറ്റുകളും, മൊത്തം വലുപ്പ വിവരങ്ങളും ചിഹ്ന പട്ടികയിൽ ആവശ്യമാണ്.


The symbol table describes the type when a type is named.

ഒരു തരം പേര് നൽകുമ്പോൾ, ചിഹ്ന പട്ടിക ആ തരം വിവരിക്കുന്നു.


Translation functions use the information in the symbol tables.

പരിഭാഷാ ഫംഗ്ഷനുകൾ ചിഹ്ന പട്ടികകളിലെ വിവരങ്ങൾ ഉപയോഗിക്കുന്നു.


It's a good idea to write translation functions for uses of names first.

പേരുകളുടെ ഉപയോഗങ്ങൾക്കായി ആദ്യം പരിഭാഷാ ഫംഗ്ഷനുകൾ എഴുതുന്നത് നല്ലതാണ്.


Chapter 10 will cover the translation of function declarations.

പത്താം അധ്യായത്തിൽ ഫംഗ്ഷൻ പ്രഖ്യാപനങ്ങളുടെ പരിഭാഷ ഉൾക്കൊള്ളുന്നു.


We can declare integer variables and one-dimensional integer arrays.

നമുക്ക് പൂർണ്ണസംഖ്യാ വേരിയബിളുകളും, ഏകമാന പൂർണ്ണസംഖ്യാ അറേകളും പ്രഖ്യാപിക്കാം.


An integer variable should be bound to a location in the symbol table.

ഒരു പൂർണ്ണസംഖ്യാ വേരിയബിൾ ചിഹ്ന പട്ടികയിലെ ഒരു സ്ഥാനത്തേക്ക് ബന്ധിപ്പിക്കണം.


Arrays are assumed to be heap allocated.

അറേകൾ കൂമ്പാരത്തിൽ അനുവദിച്ചിരിക്കുന്നു എന്ന് കരുതുന്നു.


The intermediate-code variable HP points to the first free element.

ഇടത്തരം കോഡ് വേരിയബിൾ HP, ആദ്യത്തെ ഒഴിവുള്ള ഘടകത്തിലേക്ക് ചൂണ്ടുന്നു.


No check for heap overflow is done when allocating arrays.

അറേകൾ അനുവദിക്കുമ്പോൾ കൂമ്പാരത്തിന്റെ കവിഞ്ഞൊഴുക്ക് പരിശോധിക്കുന്നില്ല.


A comprehensive discussion about intermediate languages can be found in [35].

ഇടത്തരം ഭാഷകളെക്കുറിച്ചുള്ള സമഗ്രമായ ചർച്ച [35]-ൽ കാണാം.


Functional and logic languages often use high-level intermediate languages.

പ്രവർത്തനപരവും, ലോജിക് ഭാഷകളും പലപ്പോഴും ഉയർന്ന തലത്തിലുള്ള ഇടത്തരം ഭാഷകൾ ഉപയോഗിക്കുന്നു.


JVM has single instructions for complex operations like calling virtual methods.

വെർച്വൽ രീതികൾ വിളിക്കുന്നത് പോലുള്ള സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾക്കായി JVM-ൽ ഒറ്റ നിർദ്ദേശങ്ങൾ ഉണ്ട്.


JVM was originally intended for interpretation.

JVM യഥാർത്ഥത്തിൽ രൂപകൽപ്പന ചെയ്തത് വ്യാഖ്യാനത്തിനായാണ്.


A program in JVM is validated before interpretation or further translation.

JVM-ലെ ഒരു പ്രോഗ്രാം വ്യാഖ്യാനിക്കുന്നതിനോ, തുടർന്ന് പരിഭാഷപ്പെടുത്തുന്നതിനോ മുമ്പ് സാധൂകരിക്കുന്നു.


This is easier when the code is high-level.

കോഡ് ഉയർന്ന നിലയിലായിരിക്കുമ്പോൾ ഇത് എളുപ്പമാണ്.


The compiler optimizes code to improve performance.

പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനായി കംപൈലർ കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു.


Register allocation is a crucial step in the compilation process.

കംപൈലേഷൻ പ്രക്രിയയിലെ ഒരു പ്രധാന ഘട്ടമാണ് രജിസ്റ്റർ അലോക്കേഷൻ.


Liveness analysis determines which variables are active at a given point.

ഒരു പ്രത്യേക പോയിന്റിൽ ഏതൊക്കെ വേരിയബിളുകളാണ് സജീവമായിട്ടുള്ളതെന്ന് ലൈവ്നെസ് അനാലിസിസ് നിർണ്ണയിക്കുന്നു.


The interference graph helps in register allocation.

ഇടപെടൽ ഗ്രാഫ് രജിസ്റ്റർ അലോക്കേഷനിൽ സഹായിക്കുന്നു.


Graph coloring is used to assign registers to variables.

വേരിയബിളുകൾക്ക് രജിസ്റ്ററുകൾ നൽകാൻ ഗ്രാഫ് കളറിംഗ് ഉപയോഗിക്കുന്നു.


Optimization techniques can significantly improve program speed.

ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾക്ക് പ്രോഗ്രാം വേഗത ഗണ്യമായി മെച്ചപ്പെടുത്താൻ കഴിയും.


The intermediate code is often simpler than the source code.

ഇടക്കാല കോഡ് പലപ്പോഴും സോഴ്സ് കോഡിനേക്കാൾ ലളിതമാണ്.


Common subexpression elimination reduces redundant calculations.

കോമൺ സബ്‌എക്‌സ്‌പ്രഷൻ ഒഴിവാക്കുന്നത് അധികമായുള്ള കണക്കുകൂട്ടലുകൾ കുറയ്ക്കുന്നു.


Code hoisting moves computations outside of loops.

കോഡ് ഹോയിസ്റ്റിംഗ്, ലൂപ്പുകൾക്ക് പുറത്തേക്ക് കണക്കുകൂട്ടലുകൾ നീക്കുന്നു.


Constant propagation replaces variables with their constant values.

സ്ഥിരമായ പ്രൊപ്പഗേഷൻ വേരിയബിളുകളെ സ്ഥിരമായ മൂല്യങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.


Index-check elimination removes unnecessary array bound checks.

ഇൻഡെക്സ്-ചെക്ക് ഒഴിവാക്കുന്നത് ആവശ്യമില്ലാത്ത അറേ ബൗണ്ട് പരിശോധനകൾ നീക്കം ചെയ്യുന്നു.


The MIPS architecture is a popular choice for teaching compilers.

കംപൈലറുകൾ പഠിപ്പിക്കുന്നതിന് MIPS ആർക്കിടെക്ചർ ഒരു ജനപ്രിയ തിരഞ്ഞെടുപ്പാണ്.


Understanding liveness is key to efficient register allocation.

കാര്യക്ഷമമായ രജിസ്റ്റർ അലോക്കേഷന് ലൈവ്നെസ് മനസ്സിലാക്കുന്നത് പ്രധാനമാണ്.


The compiler generates machine code from the intermediate representation.

ഇടക്കാല പ്രാതിനിധ്യത്തിൽ നിന്ന് കംപൈലർ മെഷീൻ കോഡ് ഉണ്ടാക്കുന്നു.


Register allocation aims to minimize memory access.

മെമ്മറി ആക്സസ് കുറയ്ക്കുക എന്നതാണ് രജിസ്റ്റർ അലോക്കേഷന്റെ ലക്ഷ്യം.


Spilling occurs when there are not enough registers.

രജിസ്റ്ററുകൾ ആവശ്യത്തിന് ഇല്ലാത്തപ്പോൾ സ്പില്ലിംഗ് സംഭവിക്കുന്നു.


The goal is to produce fast and efficient code.

വേഗതയേറിയതും കാര്യക്ഷമവുമായ കോഡ് നിർമ്മിക്കുക എന്നതാണ് ലക്ഷ്യം.


The program calculates the Fibonacci sequence.

പ്രോഗ്രാം ഫിബൊനാച്ചി സീക്വൻസ് കണക്കാക്കുന്നു.


കോഡ് പ്രകടനത്തിനായി ഒപ്റ്റിമൈസ് ചെയ്തിരിക്കുന്നു.


This chapter discusses register allocation.

ഈ അധ്യായത്തിൽ രജിസ്റ്റർ അലോക്കേഷനെക്കുറിച്ച് പറയുന്നു.


ഇന്ന് സൂര്യൻ ശോഭയോടെ പ്രകാശിക്കുന്നു.


അല്പം ഉപ്പ് തരുമോ?


പ്രധാന ഭൂകമ്പത്തെക്കുറിച്ച് വാർത്തയിൽ റിപ്പോർട്ട് ചെയ്തു.


അദ്ദേഹം വളരെ കഴിവുള്ള ഒരു സംഗീതജ്ഞനാണ്.


The company announced its quarterly earnings.

കമ്പനി അതിന്റെ ത്രൈമാസ വരുമാനം പ്രഖ്യാപിച്ചു.


The algorithm efficiently sorts the data.

അൽഗോരിതം ഡാറ്റയെ കാര്യക്ഷമമായി അടുക്കുന്നു.


പ്രതിസന്ധികൾക്കിടയിലും അവർ വിജയിച്ചു.


The research paper explores new findings.

ഗവേഷണ പ്രബന്ധം പുതിയ കണ്ടെത്തലുകൾ പരിശോധിക്കുന്നു.


അവൾക്ക് നിരവധി ഭാഷകളിൽ നല്ല പ്രാവീണ്യമുണ്ട്.


The meeting was postponed until next week.

അടുത്ത ആഴ്ചത്തേക്ക് യോഗം മാറ്റിവെച്ചു.


The complex system requires careful maintenance.

സങ്കീർണ്ണമായ ഈ സിസ്റ്റത്തിന് ശ്രദ്ധയോടെയുള്ള പരിപാലനം ആവശ്യമാണ്.


അദ്ദേഹം തൻ്റെ നൂതന ആശയങ്ങൾക്ക് പേരുകേട്ടതാണ്.


സാമ്പത്തിക പ്രവചനം വളർച്ച പ്രവചിക്കുന്നു.


The software update includes new features.

സോഫ്റ്റ്‌വെയർ അപ്‌ഡേറ്റിൽ പുതിയ ഫീച്ചറുകൾ ഉൾപ്പെടുന്നു.


She enjoys reading novels in her free time.

അവൾ ഒഴിവുസമയങ്ങളിൽ നോവലുകൾ വായിക്കാൻ ഇഷ്ടപ്പെടുന്നു.


പ്രോജക്റ്റ് സമയത്തിന് പിന്നിലാണ്.


The data analysis revealed interesting patterns.

ഡാറ്റാ വിശകലനം രസകരമായ പാറ്റേണുകൾ വെളിപ്പെടുത്തി.


അദ്ദേഹം വളരെ ബഹുമാനിക്കപ്പെടുന്ന ഒരു പ്രൊഫസറാണ്.


സർക്കാർ പുതിയ നയങ്ങൾ പ്രഖ്യാപിച്ചു.


കാറിൻ്റെ എഞ്ചിൻ നന്നാക്കേണ്ടതുണ്ട്.


First, all registers that can be used to hold variables are stored in the frame.

ആദ്യം, വേരിയബിളുകൾ സൂക്ഷിക്കാൻ കഴിയുന്ന എല്ലാ രജിസ്റ്ററുകളും ഫ്രെയിമിൽ സംഭരിക്കുന്നു.


Then, the frame-pointer is advanced to point to the new frame.

തുടർന്ന്, പുതിയ ഫ്രെയിമിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ ഫ്രെയിം-പോയിന്റർ മുന്നോട്ട് നീങ്ങുന്നു.


Finally, a jump to the function is made.

അവസാനമായി, ഫംഗ്ഷനിലേക്ക് ഒരു ജമ്പ് ഉണ്ടാക്കുന്നു.


When the function call returns, the result is read from the frame into the variable x.

ഫംഗ്ഷൻ കോൾ തിരികെ വരുമ്പോൾ, ഫ്രെയിമിൽ നിന്ന് x എന്ന വേരിയബിളിലേക്ക് ഫലം വായിക്കുന്നു.


Keeping all the parameters in register-allocated variables until just before the call can require a lot of registers.

എല്ലാ പാരാമീറ്ററുകളും കോളിന് തൊട്ടുമുന്‍പ് വരെ രജിസ്റ്റർ-അലോക്കേറ്റഡ് വേരിയബിളുകളിൽ സൂക്ഷിക്കുന്നത് ധാരാളം രജിസ്റ്ററുകൾ ആവശ്യമായി വന്നേക്കാം.


An alternative is to store each parameter in the frame as soon as it is evaluated.

ഓരോ പാരാമീറ്ററും മൂല്യനിർണ്ണയം ചെയ്ത ഉടൻ തന്നെ ഫ്രെയിമിൽ സംഭരിക്കുന്നതാണ് മറ്റൊരു മാർഗ്ഗം.


However, this can go wrong if a later parameter-expression contains a function call.

എങ്കിലും, ഒരു ഫംഗ്ഷൻ കോൾ അടങ്ങിയ ഒരു പിൽക്കാല പാരാമീറ്റർ-എക്സ്പ്രഷൻ ഉണ്ടായാൽ ഇത് തെറ്റാൻ സാധ്യതയുണ്ട്.


This may save more registers than needed, as not all registers will hold values that are required after the call.

എല്ലാ രജിസ്റ്ററുകളും കോളിന് ശേഷം ആവശ്യമുള്ള മൂല്യങ്ങൾ സൂക്ഷിക്കാത്തതിനാൽ ഇത് ആവശ്യത്തിലധികം രജിസ്റ്ററുകൾ ലാഭിച്ചേക്കാം.


We will return to this issue in section 10.6.

നമ്മൾ ഈ വിഷയം 10.6-ാം ഭാഗത്ത് വീണ്ടും ചർച്ച ചെയ്യുന്നതാണ്.


The convention used by the activation record layout is that, before a function is called, the caller saves all registers that must be preserved.

ആക്ടിവേഷൻ റെക്കോർഡ് ലേഔട്ട് ഉപയോഗിക്കുന്ന രീതി അനുസരിച്ച്, ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നതിന് മുമ്പ്, കോളർ സംരക്ഷിക്കേണ്ട എല്ലാ രജിസ്റ്ററുകളും സംരക്ഷിക്കുന്നു.


An alternative strategy is that the called function saves the contents of the registers that need to be preserved.

വിളിക്കപ്പെടുന്ന ഫംഗ്ഷൻ സംരക്ഷിക്കേണ്ട രജിസ്റ്ററുകളുടെ ഉള്ളടക്കം സംരക്ഷിക്കുന്നതാണ് മറ്റൊരു തന്ത്രം.


Stack-layout, prologue/epilogue and call sequence for the callee-saves strategy are shown in figures 10.4, 10.5 and 10.6.

കാലി-സേവ്സ് തന്ത്രത്തിനായുള്ള സ്റ്റാക്ക്-ലേഔട്ട്, പ്രൊലോഗ്/എപിലോഗ്, കോൾ സീക്വൻസ് എന്നിവ ചിത്രീകരിക്കുന്നത് 10.4, 10.5, 10.6 എന്നീ ചിത്രീകരണങ്ങളിൽ കാണിച്ചിരിക്കുന്നു.


However, once we refine the strategies to save only a subset of the registers that may potentially hold variables, other differences emerge.

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


Caller-saves need only save the registers that hold live variables and callee-saves need only save the registers that the function actually uses.

കോളർ-സേവ്സിന് ലൈവ് വേരിയബിളുകൾ സൂക്ഷിക്കുന്ന രജിസ്റ്ററുകൾ മാത്രമേ സംരക്ഷിക്കേണ്ടതുള്ളൂ, അതേസമയം കാലി-സേവ്സിന് ഫംഗ്ഷൻ യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്ന രജിസ്റ്ററുകൾ സംരക്ഷിക്കേണ്ടതുണ്ട്.


In both call sequences shown, parameters are stored in the frame.

കാണിച്ചിരിക്കുന്ന രണ്ട് കോൾ സീക്വൻസുകളിലും, പാരാമീറ്ററുകൾ ഫ്രെയിമിൽ സംഭരിച്ചിരിക്കുന്നു.


It will save a good deal of memory traffic if we pass the parameters in registers instead of memory.

മെമ്മറിക്ക് പകരം രജിസ്റ്ററുകളിൽ പാരാമീറ്ററുകൾ കൈമാറുകയാണെങ്കിൽ ഇത് മെമ്മറി ട്രാഫിക് വളരെയധികം ലാഭിക്കും.


Since most functions have fairly short parameter lists, most parameters will normally be passed in registers.

മിക്ക ഫംഗ്ഷനുകൾക്കും വളരെ ചെറിയ പാരാമീറ്റർ ലിസ്റ്റുകൾ ഉള്ളതിനാൽ, മിക്ക പാരാമീറ്ററുകളും സാധാരണയായി രജിസ്റ്ററുകളിൽ കൈമാറ്റം ചെയ്യപ്പെടും.


Note that the return address is also passed in a register.

റിട്ടേൺ വിലാസവും ഒരു രജിസ്റ്ററിൽ കൈമാറുന്നു എന്നത് ശ്രദ്ധിക്കുക.


Most RISC architectures have jump-and-link (function-call) instructions, which leaves the return address in a register, so this is only natural.

മിക്ക RISC ആർക്കിടെക്ചറുകളിലും ജമ്പ്-ആൻഡ്-ലിങ്ക് (ഫംഗ്ഷൻ-കോൾ) നിർദ്ദേശങ്ങൾ ഉണ്ട്, ഇത് റിട്ടേൺ വിലാസം ഒരു രജിസ്റ്ററിൽ നിലനിർത്തുന്നു, അതിനാൽ ഇത് വളരെ സ്വാഭാവികമാണ്.


The register allocator can tell which variables are live after the function call.

ഫംഗ്ഷൻ കോളിന് ശേഷം ഏതൊക്കെ വേരിയബിളുകളാണ് ലൈവ് ആയിട്ടുള്ളതെന്ന് രജിസ്റ്റർ അലോക്കേറ്റർക്ക് പറയാൻ കഴിയും.


The compiler optimizes code to improve performance.

പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനായി കംപൈലർ കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നു.


Data-flow analysis is crucial for optimization.

ഒപ്റ്റിമൈസേഷനായി ഡാറ്റാ-ഫ്ലോ വിശകലനം അത്യാവശ്യമാണ്.


Loop unrolling can enhance program speed.

ലൂപ്പ് അൺറോളിംഗ് പ്രോഗ്രാം വേഗത വർദ്ധിപ്പിക്കും.


Index-check elimination reduces overhead.

ഇൻഡെക്സ്-ചെക്ക് ഒഴിവാക്കുന്നത് അധിക ചിലവ് കുറയ്ക്കുന്നു.


Code hoisting moves loop-invariant computations.

കോഡ് ഹോയിസ്റ്റിംഗ് ലൂപ്പ്-ഇൻവേരിയന്റ് കണക്കുകൂട്ടലുകൾ നീക്കുന്നു.


Prefetching can improve cache utilization.

പ്രീഫെച്ചിംഗിന് കാഷെ ഉപയോഗം മെച്ചപ്പെടുത്താൻ കഴിയും.


Inlining replaces function calls with function bodies.

ഇൻലൈനിംഗ് ഫംഗ്ഷൻ കോളുകൾ ഫംഗ്ഷൻ ബോഡികളുമായി മാറ്റിസ്ഥാപിക്കുന്നു.


Tail-call optimization avoids unnecessary stack frames.

ടെയിൽ-കോൾ ഒപ്റ്റിമൈസേഷൻ, ആവശ്യമില്ലാത്ത സ്റ്റാക്ക് ഫ്രെയിമുകൾ ഒഴിവാക്കുന്നു.


The program's performance was significantly improved.

പ്രോഗ്രാമിന്റെ പ്രകടനം കാര്യമായി മെച്ചപ്പെട്ടു.


The analysis identifies redundant computations.

അനാവശ്യമായ കണക്കുകൂട്ടലുകൾ വിശകലനം തിരിച്ചറിയുന്നു.


The algorithm is designed for efficiency.

ഈ അൽഗോരിതം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് കാര്യക്ഷമതയ്ക്ക് വേണ്ടിയാണ്.


The compiler performs various optimizations.

കംപൈലർ വിവിധ ഒപ്റ്റിമൈസേഷനുകൾ നടത്തുന്നു.


കോഡ് വേഗതയ്ക്കായി ഒപ്റ്റിമൈസ് ചെയ്തു.


ഈ രീതി എക്സിക്യൂഷൻ സമയം കുറയ്ക്കുന്നു.


The goal is to improve program efficiency.

പ്രോഗ്രാം കാര്യക്ഷമത മെച്ചപ്പെടുത്തുക എന്നതാണ് ലക്ഷ്യം.


സിസ്റ്റം ഡാറ്റാ-ഫ്ലോ വിശകലനം ഉപയോഗിക്കുന്നു.


ഒപ്റ്റിമൈസേഷൻ പ്രക്രിയ സങ്കീർണ്ണമാണ്.


The compiler's job is to translate code.

കോഡ് വിവർത്തനം ചെയ്യുക എന്നതാണ് കംപൈലറുടെ ജോലി.


The program runs faster after optimization.

ഒപ്റ്റിമൈസേഷനു ശേഷം പ്രോഗ്രാം വേഗത്തിൽ പ്രവർത്തിക്കുന്നു.


തെറ്റുകൾ കണ്ടെത്താൻ ഈ വിശകലനം സഹായിക്കുന്നു.


The function call eliminates the need to save and restore variables.

വിളിച്ച ഫംഗ്ഷൻ വേരിയബിളുകൾ സംരക്ഷിക്കേണ്ടതിൻ്റെ ആവശ്യകത ഇല്ലാതാക്കുന്നു.


If we can eliminate the epilogue, we can make g return directly to f's caller.

എപ്പിലോഗ് ഒഴിവാക്കാൻ കഴിഞ്ഞാൽ, g-യെ f-ൻ്റെ കോളറിലേക്ക് നേരിട്ട് തിരികെ നൽകാൻ കഴിയും.


We can reuse the frame for f as the frame for g.

f-ൻ്റെ ഫ്രെയിമിനായി g-യുടെ ഫ്രെയിം വീണ്ടും ഉപയോഗിക്കാൻ കഴിയും.


The combined call sequence of the call to g and the epilogue of f becomes complex.

g-യിലേക്കുള്ള കോളും f-ൻ്റെ എപ്പിലോഗും ചേർന്നുള്ള കോൾ സീക്വൻസ് സങ്കീർണ്ണമാവുന്നു.


Since there are no live variables after the call to g, we can eliminate saving and restoring.

g-യിലേക്ക് വിളിച്ചതിന് ശേഷം ലൈവ് വേരിയബിളുകളൊന്നും ഇല്ലാത്തതിനാൽ, സംരക്ഷിക്കുകയും പുനഃസ്ഥാപിക്കുകയും ചെയ്യുന്നത് ഒഴിവാക്കാം.


We now see that all that happens after we return is an adjustment of FP.

തിരിച്ചെത്തിയ ശേഷം FP-യുടെ ക്രമീകരണം മാത്രമാണ് സംഭവിക്കുന്നതെന്ന് ഇപ്പോൾ നമുക്ക് കാണാം.


What we now want is to reuse f's frame for g's frame.

g-യുടെ ഫ്രെയിമിനായി f-ൻ്റെ ഫ്രെയിം വീണ്ടും ഉപയോഗിക്കാനാണ് നമ്മൾ ഇപ്പോൾ ആഗ്രഹിക്കുന്നത്.


We do this by not adding and subtracting f's frame size from FP.

FP-യിൽ നിന്ന് f-ൻ്റെ ഫ്രെയിം വലുപ്പം കൂട്ടുകയും കുറയ്ക്കുകയും ചെയ്യാതിരിക്കുന്നതിലൂടെ ഇത് സാധ്യമാക്കുന്നു.


It is immediately evident that the two instructions that copy the result from and to the frame cancel out.

ഫലങ്ങൾ ഫ്രെയിമിലേക്ക് പകർത്തുന്ന രണ്ട് നിർദ്ദേശങ്ങൾ റദ്ദാക്കുന്നു എന്നത് ഉടനടി വ്യക്തമാണ്.


We also see an unfortunate problem: Just before the call to g, we overwrite f's return address.

g-യിലേക്ക് വിളിക്കുന്നതിന് തൊട്ടുമുന്‍പ്, f-ൻ്റെ റിട്ടേൺ വിലാസം നമ്മൾ തിരുത്തിയെഴുതുന്നു: നിർഭാഗ്യകരമായ ഒരു പ്രശ്നം.


Since all that happens after we return from g is a return from f, we can make g return directly to f's caller.

g-യിൽ നിന്ന് തിരികെ വരുമ്പോൾ f-ൽ നിന്നുള്ള ഒരു മടക്കം മാത്രമാണ് സംഭവിക്കുന്നതെങ്കിൽ, g-യെ f-ൻ്റെ കോളറിലേക്ക് നേരിട്ട് തിരികെ നൽകാൻ കഴിയും.


With this tail-call optimisation, we have eliminated the potential ill effects of reusing f's frame for g.

ഈ ടെയിൽ-കോൾ ഒപ്റ്റിമൈസേഷൻ ഉപയോഗിച്ച്, g-യുടെ ഫ്രെയിമിനായി f-ൻ്റെ ഫ്രെയിം വീണ്ടും ഉപയോഗിക്കുന്നതിൻ്റെ ദോഷകരമായ ഫലങ്ങൾ നമ്മൾ ഒഴിവാക്കിയിരിക്കുന്നു.


Functional programming languages rely on this space saving.

ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ഭാഷകൾ ഈ സ്പേസ് ലാഭത്തെ ആശ്രയിക്കുന്നു.


By doing tail-call optimisation, an arbitrarily long sequence of recursive tail calls can share the same stack frame.

ടെയിൽ-കോൾ ഒപ്റ്റിമൈസേഷൻ ചെയ്യുന്നതിലൂടെ, വളരെ വലിയ അളവിലുള്ള റിcursive ടെയിൽ കോളുകൾക്ക് ഒരേ സ്റ്റാക്ക് ഫ്രെയിം പങ്കിടാൻ കഴിയും.


If a callee-saves strategy or a mixed caller-saves/callee-saves strategy is used, there will still be no saving and restoring around the call.

ഒരു കാലി-സേവ്സ് തന്ത്രമോ അല്ലെങ്കിൽ ഒരു മിശ്രിത കോളർ-സേവ്സ്/കാലി-സേവ്സ് തന്ത്രമോ ഉപയോഗിക്കുകയാണെങ്കിൽ, കോളിന് ചുറ്റും സംരക്ഷിക്കുകയോ പുനഃസ്ഥാപിക്കുകയോ ചെയ്യില്ല.


Modern programs consist mainly of calls to predefined library functions.

ആധുനിക പ്രോഗ്രാമുകൾ പ്രധാനമായും മുൻകൂട്ടി നിർവചിക്കപ്പെട്ട ലൈബ്രറി ഫംഗ്ഷനുകളിലേക്കുള്ള കോളുകൾ ഉൾക്കൊള്ളുന്നു.


Calls to such library functions often fix some of the parameters to constants.

അത്തരം ലൈബ്രറി ഫംഗ്ഷനുകളിലേക്കുള്ള കോളുകൾ പലപ്പോഴും ചില പാരാമീറ്ററുകൾ സ്ഥിരമായ സംഖ്യകളായി നൽകുന്നു.


For example, a function that raises a number to a power is often called with a constant as the power.

ഉദാഹരണത്തിന്, ഒരു സംഖ്യയെ കൃത്യമായ ഒരു power-ലേക്ക് ഉയർത്തുന്ന ഫംഗ്ഷൻ പലപ്പോഴും ഒരു സ്ഥിര സംഖ്യ power ആയി ഉപയോഗിച്ച് വിളിക്കുന്നു.


In such cases, the generality of the library function is wasted.

അത്തരം സന്ദർഭങ്ങളിൽ, ലൈബ്രറി ഫംഗ്ഷൻ്റെ പൊതുവായ സ്വഭാവം പാഴായിപ്പോകുന്നു.


Executing power5(x) is, obviously, a lot faster than executing power(x,5).

power5(x) നടപ്പിലാക്കുന്നത്, power(x,5) നടപ്പിലാക്കുന്നതിനേക്കാൾ വളരെ വേഗത്തിലാണ്.


The garbage collector moves objects to free up memory.

മെമ്മറി സ്വതന്ത്രമാക്കാൻ ഗാർബേജ് കളക്ടർ ഒബ്ജക്റ്റുകളെ നീക്കുന്നു.


Generational collectors are a refinement of tracing collectors.

തലമുറ കളക്ടറുകൾ ട്രേസിംഗ് കളക്ടറുകളുടെ ഒരു പരിഷ്കരണമാണ്.


The program needs to react quickly to outside changes.

പ്രോഗ്രാം പുറത്തുള്ള മാറ്റങ്ങളോട് വേഗത്തിൽ പ്രതികരിക്കേണ്ടതുണ്ട്.


ഇതൊരു സങ്കീർണ്ണമായ പ്രക്രിയയാണ്.


കമ്പ്യൂട്ടർ കോഡിനെ വിവർത്തനം ചെയ്യുന്നു.


Bootstrapping is a crucial step in compiler development.

കമ്പൈലർ വികസിപ്പിക്കുന്നതിൽ ബൂട്ട്‌സ്‌ട്രാപ്പിംഗ് ഒരു നിർണായക ഘട്ടമാണ്.


The machine directly executes language D.

യന്ത്രം നേരിട്ട് D ഭാഷ നടപ്പിലാക്കുന്നു.


We want to have a compiler that runs on the new processor.

പുതിയ പ്രോസസ്സറിൽ പ്രവർത്തിക്കുന്ന ഒരു കംപൈലർ ഞങ്ങൾക്ക് വേണം.


കംപൈലർ A ഭാഷയിലാണ് എഴുതിയിരിക്കുന്നത്.


The program can simply call the collector regularly.

പ്രോഗ്രാമിന് കളക്ടറെ പതിവായി വിളിക്കാൻ കഴിയും.


The compiler generates ARM machine code.

കംപൈലർ ARM മെഷീൻ കോഡ് ഉണ്ടാക്കുന്നു.


ഇത് നിരവധി പ്രശ്നങ്ങൾക്ക് കാരണമാകുന്നു.


The basic idea in bootstrapping is to use compilers to compile themselves.

ബൂട്ട്‌സ്‌ട്രാപ്പിംഗിലെ അടിസ്ഥാന ആശയം കംപൈലറുകൾ ഉപയോഗിച്ച് അവയെത്തന്നെ കംപൈൽ ചെയ്യുക എന്നതാണ്.


The input to the compiler is the source program.

കംപൈലറിലേക്കുള്ള ഇൻപുട്ട് സോഴ്സ് പ്രോഗ്രാം ആണ്.


The resulting output is the target program.

അതിന്റെ ഫലമായുള്ള ഔട്ട്‌പുട്ട് ടാർഗെറ്റ് പ്രോഗ്രാം ആണ്.


The languages must match at every connection.

എല്ലാ കണക്ഷനുകളിലും ഭാഷകൾ പൊരുത്തപ്പെടണം.


We can insert an interpreter into this picture.

ഈ ചിത്രത്തിലേക്ക് ഒരു ഇന്റർപ്രെറ്റർ ചേർക്കാൻ കഴിയും.


The compiler can now be used to compile itself.

കംപൈലർ ഇപ്പോൾ സ്വയം കംപൈൽ ചെയ്യാൻ ഉപയോഗിക്കാം.


Such combinations can be a bit confusing.

അത്തരം കോമ്പിനേഷനുകൾ അൽപ്പം ആശയക്കുഴപ്പമുണ്ടാക്കാം.


When no existing compiler is available, we need full bootstrapping.

നിലവിൽ ഒരു കംപൈലറും ലഭ്യമല്ലാത്തപ്പോൾ, നമുക്ക് പൂർണ്ണമായ ബൂട്ട്‌സ്‌ട്രാപ്പിംഗ് ആവശ്യമാണ്.


അഭിപ്രായങ്ങൾ അടുക്കിയിരിക്കുന്നു.


സാധാരണ ഉപ-പ്രകടനങ്ങൾ ഒഴിവാക്കുന്നു.


കംപൈൽ ചെയ്യാനുള്ള സമയം.


കംപൈലറുകൾ കംപൈൽ ചെയ്യുന്നു.


കുറയ്ക്കുക-കുറയ്ക്കുക തർക്കം.


മാറ്റുക-കുറയ്ക്കുക തർക്കം.


സ്ഥിരതയുള്ള.


ഓപ്പറാൻഡിലെ സ്ഥിരമായത്.


സ്ഥിരമായ പ്രചരണം.


സന്ദർഭോചിതമല്ലാത്ത വ്യാകരണം.


സന്ദർഭോചിതമല്ലാത്ത ഭാഷ.


തൂങ്ങിക്കിടക്കുന്ന എൽസ്.


ഡാറ്റാ-ഒഴുക്ക് വിശകലനം.


പ്രയോജനമില്ലാത്ത കോഡ് ഒഴിവാക്കൽ.


നിർണ്ണായക ഫൈനൈറ്റ് ഓട്ടോമാറ്റൺ.


NFA-യെ DFA-ആയി മാറ്റുന്നു.


When freeing a block, we subtract one from the size, look that many bytes ahead to see if the size field stored in this word is even.

ഒരു ബ്ലോക്ക് സ്വതന്ത്രമാക്കുമ്പോൾ, വലുപ്പത്തിൽ നിന്ന് ഒന്ന് കുറയ്ക്കുന്നു, ഈ വാക്കിൽ സംഭരിച്ചിരിക്കുന്ന വലുപ്പ ഫീൽഡ് ഇരട്ടയാണോ എന്ന് പരിശോധിക്കാൻ അത്രയും ബൈറ്റുകൾ മുന്നോട്ട് നോക്കുക.


If so, we add the sizes and store the sum in the size field of the released block, remove its neighbour from the free list and add the joined block to it.

അങ്ങനെയാണെങ്കിൽ, വലുപ്പങ്ങൾ ചേർത്ത് റിലീസ് ചെയ്ത ബ്ലോക്കിന്റെ വലുപ്പ ഫീൽഡിൽ സം зберігаിക്കുന്നു, അതിന്റെ അയൽക്കാരനെ ഫ്രീ ലിസ്റ്റിൽ നിന്ന് നീക്കം ചെയ്ത് ജോയിൻ ചെയ്ത ബ്ലോക്ക് അതിലേക്ക് ചേർക്കുക.


Note that the order of freeing blocks can determine if blocks are joined.

ബ്ലോക്കുകൾ സ്വതന്ത്രമാക്കുന്ന ക്രമം ബ്ലോക്കുകൾ ചേരുന്നത് നിർണ്ണയിക്കാൻ കഴിയും എന്നത് ശ്രദ്ധിക്കുക.


Two neighbours are only joined if the one at the highest address is freed before its lower- address neighbour.

ഏറ്റവും ഉയർന്ന വിലാസത്തിലുള്ള ഒന്ന്, താഴ്ന്ന വിലാസത്തിലുള്ള അയൽക്കാരന് മുമ്പ് സ്വതന്ത്രമാക്കിയാൽ മാത്രമേ രണ്ട് അയൽക്കാരെയും ബന്ധിപ്പിക്കുകയുള്ളൂ.


With this modification, free() is again constant time, but we merge fewer blocks than otherwise.

ഈ മാറ്റം വരുത്തുന്നതിലൂടെ, free() വീണ്ടും സ്ഥിര സമയമെടുക്കും, എന്നാൽ മറ്റു രീതികളെക്കാൾ കുറഞ്ഞ ബ്ലോക്കുകൾ മാത്രമേ നമ്മൾ ലയിപ്പിക്കുകയുള്ളൂ.


To reduce the time used for searching for a sufficiently large block when calling malloc(), we can keep free blocks sorted by size.

malloc() വിളിക്കുമ്പോൾ ആവശ്യത്തിന് വലിയ ബ്ലോക്ക് തിരയുന്നതിന് എടുക്കുന്ന സമയം കുറയ്ക്കുന്നതിന്, നമുക്ക് ഫ്രീ ബ്ലോക്കുകൾ വലുപ്പത്തിനനുസരിച്ച് അടുക്കി സൂക്ഷിക്കാം.


A common strategy for this is limiting block sizes (including size fields) to powers of two and keeping a free list for each size.

ഇതിനായുള്ള ഒരു സാധാരണ തന്ത്രം ബ്ലോക്ക് വലുപ്പങ്ങൾ (വലുപ്പ ഫീൽഡുകൾ ഉൾപ്പെടെ) രണ്ടിന്റെ ശക്തികളിലേക്ക് പരിമിതപ്പെടുത്തുകയും ഓരോ വലുപ്പത്തിനും ഒരു ഫ്രീ ലിസ്റ്റ് സൂക്ഷിക്കുകയും ചെയ്യുക എന്നതാണ്.


When malloc(n) is called, we find the nearest power of two that is at least n+wordsize, remove the first block in the free list for that size and return this.

malloc(n) എന്ന് വിളിക്കുമ്പോൾ, n+wordsize-ൽ കുറയാത്ത രണ്ടിന്റെ ഏറ്റവും അടുത്തുള്ള ശക്തി കണ്ടെത്തുകയും, ആ വലുപ്പത്തിലുള്ള ഫ്രീ ലിസ്റ്റിലെ ആദ്യ ബ്ലോക്ക് നീക്കം ചെയ്യുകയും ഇത് തിരികെ നൽകുകയും ചെയ്യുന്നു.


If the relevant free list is empty, we take the first block in the next free list and split this into two equal-size blocks, put one of these into the previous free list and return the other.

ബന്ധപ്പെട്ട ഫ്രീ ലിസ്റ്റ് കാലിയാണെങ്കിൽ, അടുത്ത ഫ്രീ ലിസ്റ്റിലെ ആദ്യ ബ്ലോക്ക് എടുത്ത് തുല്യ വലുപ്പത്തിലുള്ള രണ്ട് ബ്ലോക്കുകളായി വിഭജിക്കുന്നു, ഇവയിലൊന്ന് മുൻ ഫ്രീ ലിസ്റ്റിൽ വെച്ച് മറ്റൊന്ന് തിരികെ നൽകുന്നു.


If all free lists are empty, we allocate a new chunk from the operating system.

എല്ലാ ഫ്രീ ലിസ്റ്റുകളും കാലിയാണെങ്കിൽ, ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ നിന്ന് ഒരു പുതിയ ഭാഗം അനുവദിക്കുന്നു.


The worst-case time for a single call to malloc() is, hence, logarithmic in the size of the total heap memory.

അതുകൊണ്ട് തന്നെ, malloc() എന്ന ഒറ്റ കോളിനായുള്ള ഏറ്റവും മോശം സമയം, മൊത്തം ഹീപ് മെമ്മറിയുടെ വലുപ്പത്തിൽ ലോഗരിതമിക് ആയിരിക്കും.


To reduce fragmentation and allow fast joining of freed blocks, some memory managers restrict blocks to be aligned to block size.

വിഭജനം കുറക്കുന്നതിനും, സ്വതന്ത്രമാക്കിയ ബ്ലോക്കുകൾ വേഗത്തിൽ കൂട്ടിച്ചേർക്കുന്നതിനും, ചില മെമ്മറി മാനേജർമാർ ബ്ലോക്കുകളെ ബ്ലോക്ക് വലുപ്പത്തിലേക്ക് ക്രമീകരിക്കുന്നു.


When joining blocks, we can only do so if the resulting joined block is aligned to its size, so some blocks can only be joined with the next (higher-address) block of the same size and some only with the previous (lower-address) block of the same size.

ബ്ലോക്കുകൾ ചേർക്കുമ്പോൾ, ഫലമായുണ്ടാകുന്ന ബ്ലോക്ക് അതിന്റെ വലുപ്പത്തിലേക്ക് ക്രമീകരിച്ചിട്ടുണ്ടെങ്കിൽ മാത്രമേ നമുക്ക് അങ്ങനെ ചെയ്യാൻ കഴിയൂ, അതിനാൽ ചില ബ്ലോക്കുകൾക്ക് അതേ വലുപ്പത്തിലുള്ള അടുത്ത (കൂടുതൽ വിലാസമുള്ള) ബ്ലോക്കുമായും, ചിലത് തൊട്ടുമുമ്പത്തെ (കുറഞ്ഞ വിലാസമുള്ള) ബ്ലോക്കുമായും മാത്രമേ ചേർക്കാൻ കഴിയൂ.


Two blocks that can be joined are called “buddies”, and each block has an unique buddy.

ചേർക്കാൻ കഴിയുന്ന രണ്ട് ബ്ലോക്കുകളെ “ബഡ്ഡീസ്” എന്ന് വിളിക്കുന്നു, കൂടാതെ ഓരോ ബ്ലോക്കിനും ഒരു അദ്വിതീയ ബഡ്ഡിയുണ്ട്.


Like in section 12.5.2, we use a bit in the size field to indicate that a block is in use.

വിഭാഗം 12.5.2-ൽ പറഞ്ഞതുപോലെ, ഒരു ബ്ലോക്ക് ഉപയോഗത്തിലുണ്ടെന്ന് സൂചിപ്പിക്കാൻ വലുപ്പ ഫീൽഡിൽ ഒരു ബിറ്റ് ഉപയോഗിക്കുന്നു.


When we free a block, we clear this bit and look at the size field of the buddy.

ഒരു ബ്ലോക്ക് ഫ്രീ ചെയ്യുമ്പോൾ, ഈ ബിറ്റ് മായ്‌ക്കുകയും ബഡ്ഡിയുടെ വലുപ്പ ഫീൽഡ് പരിശോധിക്കുകയും ചെയ്യുന്നു.


If the buddy is not in use (indicated by having an even size field) and is the same size as the freed block, we merge the two blocks simply by doubling the size in the size field of the buddy with the lowest address.

ബഡ്ഡി ഉപയോഗത്തിലില്ലെങ്കിൽ (ഇരട്ട വലുപ്പ ഫീൽഡ് ഉണ്ടായിരിക്കുന്നതിലൂടെ ഇത് സൂചിപ്പിക്കുന്നു) കൂടാതെ ഫ്രീ ചെയ്ത ബ്ലോക്കിന്റെ അതേ വലുപ്പമാണെങ്കിൽ, ഏറ്റവും കുറഞ്ഞ വിലാസമുള്ള ബഡ്ഡിയുടെ വലുപ്പ ഫീൽഡിലെ വലുപ്പം ഇരട്ടിയാക്കി രണ്ട് ബ്ലോക്കുകളും ലയിപ്പിക്കുന്നു.


We remove the already-free buddy from its free list and add the joined block to the next free list.

മുമ്പേ ഫ്രീ ചെയ്ത ബഡ്ഡിയെ അതിന്റെ ഫ്രീ ലിസ്റ്റിൽ നിന്ന് നീക്കം ചെയ്യുകയും, ജോയിൻ ചെയ്ത ബ്ലോക്ക് അടുത്ത ഫ്രീ ലിസ്റ്റിൽ ചേർക്കുകയും ചെയ്യുന്നു.


Once we have joined two buddies, the newly joined block might be joined with its own buddy in the same way.

രണ്ട് ബഡ്ഡീസിനെ ചേർത്തുകഴിഞ്ഞാൽ, പുതുതായി ചേർത്ത ബ്ലോക്ക് അതേ രീതിയിൽ അതിന്റെ സ്വന്തം ബഡ്ഡിയുമായി ചേർന്നേക്കാം.


This can cause a chain of joinings, making free() take time logarithmic in the size of memory.

ഇത് ജോയിനിംഗുകളുടെ ഒരു ശൃംഖലയ്ക്ക് കാരണമായേക്കാം, ഇത് free() മെമ്മറിയുടെ വലുപ്പത്തിൽ ലോഗരിതമിക് സമയം എടുക്കാൻ ഇടയാക്കും.


The compiler design is a complex process.

കംപൈലർ രൂപകൽപ്പന ഒരു സങ്കീർണ്ണമായ പ്രക്രിയയാണ്.


Bootstrapping allows a compiler to be written in its own language.

ബൂട്ട്‌സ്‌ട്രാപ്പിംഗ് ഒരു കംപൈലറിനെ സ്വന്തം ഭാഷയിൽ എഴുതാൻ അനുവദിക്കുന്നു.


The QAD compiler doesn't need to generate code for the target machine.

QAD കംപൈലറിന് ടാർഗെറ്റ് മെഷീനിനായി കോഡ് ഉണ്ടാക്കേണ്ടതില്ല.


We can use an interpreter instead of a QAD compiler.

QAD കംപൈലറിനുപകരം നമുക്ക് ഒരു ഇന്റർപ്രെറ്റർ ഉപയോഗിക്കാം.


Incremental bootstrapping can improve compiler quality.

വർദ്ധിച്ചുവരുന്ന ബൂട്ട്‌സ്‌ട്രാപ്പിംഗിന് കംപൈലർ ഗുണമേന്മ മെച്ചപ്പെടുത്താൻ കഴിയും.


The article discusses compiler bootstrapping techniques.

ഈ ലേഖനത്തിൽ കംപൈലർ ബൂട്ട്‌സ്‌ട്രാപ്പിംഗ് രീതികളെക്കുറിച്ച് പറയുന്നു.


A compiler translates source code into machine code.

ഒരു കംപൈലർ സോഴ്സ് കോഡിനെ മെഷീൻ കോഡിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.


The first Pascal compiler used incremental bootstrapping.

ആദ്യത്തെ പാസ്കൽ കംപൈലർ ഇൻക്രിമെന്റൽ ബൂട്ട്‌സ്‌ട്രാപ്പിംഗ് ഉപയോഗിച്ചു.


Set theory is a fundamental concept in mathematics.

ഗണിതശാസ്ത്രത്തിലെ അടിസ്ഥാനപരമായ ആശയമാണ് സെറ്റ് തിയറി.


The union of two sets includes all elements from both.

രണ്ട് സെറ്റുകളുടെ യൂണിയനിൽ, രണ്ട് സെറ്റുകളിലെയും എല്ലാ അംഗങ്ങളും ഉൾപ്പെടുന്നു.


Set intersection finds elements common to both sets.

സെറ്റ് ഇന്റർസെക്ഷൻ രണ്ട് സെറ്റുകളിലും പൊതുവായ അംഗങ്ങളെ കണ്ടെത്തുന്നു.


The set difference contains elements in the first set but not the second.

സെറ്റ് വ്യത്യാസം, ആദ്യത്തെ സെറ്റിലെ അംഗങ്ങളെയും എന്നാൽ രണ്ടാമത്തെ സെറ്റിൽ ഇല്ലാത്ത അംഗങ്ങളെയും ഉൾക്കൊള്ളുന്നു.


A subset is a set whose elements are all contained within another set.

ഒരു ഉപസെറ്റ് എന്നാൽ, മറ്റൊരു സെറ്റിൽ ഉൾപ്പെടുന്ന എല്ലാ അംഗങ്ങളുമുള്ള ഒരു സെറ്റാണ്.


Set-builder notation provides a flexible way to define sets.

സെറ്റുകൾ നിർവചിക്കാൻ സെറ്റ്-ബിൽഡർ നൊട്ടേഷൻ ഒരു വഴക്കം നൽകുന്നു.


Monotonic functions are crucial for solving set equations.

സെറ്റ് സമവാക്യങ്ങൾ പരിഹരിക്കുന്നതിൽ മോണോടോണിക് ഫംഗ്ഷനുകൾ നിർണായകമാണ്.


Fixed-point iteration is used to find solutions to set equations.

സെറ്റ് സമവാക്യങ്ങൾക്കുള്ള പരിഹാരങ്ങൾ കണ്ടെത്താൻ ഫിക്സഡ്-പോയിന്റ്迭代ഷൻ ഉപയോഗിക്കുന്നു.


Distributive functions simplify the process of solving set equations.

സെറ്റ് സമവാക്യങ്ങൾ പരിഹരിക്കുന്ന പ്രക്രിയ ലളിതമാക്കാൻ വിതരണ ഫംഗ്ഷനുകൾ സഹായിക്കുന്നു.


Simultaneous set equations can be solved using fixed-point iteration.

ഫിക്സഡ്-പോയിന്റ്迭代ഷൻ ഉപയോഗിച്ച് ഒരേസമയത്തുള്ള സെറ്റ് സമവാക്യങ്ങൾ പരിഹരിക്കാൻ കഴിയും.


The compiler optimization process improves code performance.

കംപൈലർ ഒപ്റ്റിമൈസേഷൻ പ്രക്രിയ കോഡിന്റെ പ്രകടനം മെച്ചപ്പെടുത്തുന്നു.


Understanding set theory is essential for computer science.

കമ്പ്യൂട്ടർ സയൻസിൻ്റെ അടിസ്ഥാനപരമായ കാര്യങ്ങൾ മനസ്സിലാക്കാൻ സെറ്റ് തിയറി അത്യാവശ്യമാണ്.