కంపైలర్ అంటే ఏమిటి?


కంపైలర్ యొక్క దశలు చాలా ముఖ్యమైనవి.


Interpreters are also used in programming.

ప్రోగ్రామింగ్‌లో ఇంటర్‌ప్రెటర్లను కూడా ఉపయోగిస్తారు.


కంపైలర్‌ల గురించి ఎందుకు నేర్చుకోవాలి?


ఈ పుస్తకం బాగా నిర్మాణం చేయబడింది.


అధ్యాపకుడికి తెలియజేయాలి.


మేము సహకారాలను అంగీకరిస్తున్నాము.


Permission to use the content is granted.

విషయాన్ని ఉపయోగించడానికి అనుమతి ఉంది.


పద విశ్లేషణ మొదటి దశ.


రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లు శక్తివంతమైన సాధనాలు.


షార్ట్‌హ్యాండ్‌లు వ్యక్తీకరణలను సరళీకృతం చేయగలవు.


కొన్ని ఉదాహరణలను చూద్దాం.


Nondeterministic finite automata are complex.

నిర్ధారితం కాని పరిమిత ఆటోమాటాలు సంక్లిష్టంగా ఉంటాయి.


Converting a regular expression to an NFA is a process.

రెగ్యులర్ ఎక్స్‌ప్రెషన్‌ను NFAగా మార్చడం ఒక ప్రక్రియ.


ఆప్టిమైజేషన్‌లు పనితీరును మెరుగుపరుస్తాయి.


నిర్ధారిత పరిమిత ఆటోమాటాలను ఉపయోగిస్తారు.


Converting an NFA to a DFA is a key step.

NFAని DFAగా మార్చడం ఒక ముఖ్యమైన దశ.


పరిమాణం మరియు వేగం ఒక రాజీ.


DFAల కనిష్టీకరణ ముఖ్యం.


లెక్సర్ జనరేటర్లు సహాయకరమైన సాధనాలు.


The compiler translates high-level code into machine language.

కంపైలర్ ఉన్నత స్థాయి కోడ్‌ను మెషిన్ లాంగ్వేజ్‌లోకి అనువదిస్తుంది.


Lexical analysis divides the code into tokens.

లెక్సికల్ విశ్లేషణ కోడ్‌ను టోకెన్‌లుగా విభజిస్తుంది.


సింటాక్స్ విశ్లేషణ సింటాక్స్ చెట్టును సృష్టిస్తుంది.


Type checking ensures the program's consistency.

టైప్ చెకింగ్ ప్రోగ్రామ్ యొక్క స్థిరత్వాన్ని నిర్ధారిస్తుంది.


A compiler is essential for software development.

సాఫ్ట్‌వేర్ అభివృద్ధికి కంపైలర్ చాలా అవసరం.


High-level languages make programming easier.

అధిక స్థాయి భాషలు ప్రోగ్రామింగ్‌ను సులభతరం చేస్తాయి.


The compiler identifies and reports programmer mistakes.

కంపైలర్ ప్రోగ్రామర్ తప్పులను గుర్తిస్తుంది మరియు నివేదిస్తుంది.


Programs written in high-level languages are often shorter.

అధిక స్థాయి భాషలలో వ్రాసిన ప్రోగ్రామ్‌లు తరచుగా చిన్నవిగా ఉంటాయి.


The same program can run on different machines.

ఒకే ప్రోగ్రామ్ వివిధ యంత్రాలపై అమలు చేయబడుతుంది.


Good compilers optimize code for performance.

మంచి కంపైలర్‌లు పనితీరు కోసం కోడ్‌ను ఆప్టిమైజ్ చేస్తాయి.


The compilation process involves several phases.

కంపైలేషన్ ప్రక్రియలో అనేక దశలు ఉంటాయి.


Each phase has a well-defined interface.

ప్రతి దశకు బాగా నిర్వచించబడిన ఇంటర్‌ఫేస్ ఉంది.


Lexical analysis is the initial phase of compilation.

లెక్సికల్ విశ్లేషణ కంపైలేషన్ యొక్క ప్రారంభ దశ.


Syntax analysis arranges tokens into a tree structure.

సింటాక్స్ విశ్లేషణ టోకెన్‌లను చెట్టు నిర్మాణంలో అమరుస్తుంది.


Type checking ensures variable types are consistent.

టైప్ చెకింగ్ వేరియబుల్ రకాలు స్థిరంగా ఉన్నాయని నిర్ధారిస్తుంది.


Understanding compiler phases is crucial for optimization.

ఆప్టిమైజేషన్ కోసం కంపైలర్ దశలను అర్థం చేసుకోవడం చాలా ముఖ్యం.


The compiler bridges the gap between high-level and low-level languages.

కంపైలర్ ఉన్నత స్థాయి మరియు తక్కువ స్థాయి భాషల మధ్య అంతరాన్ని తగ్గిస్తుంది.


A good compiler can generate code that is close to hand-written machine code.

మంచి కంపైలర్ చేతితో వ్రాసిన మెషిన్ కోడ్‌కు దగ్గరగా ఉండే కోడ్‌ను ఉత్పత్తి చేయగలదు.


The design of a compiler involves breaking down the task into manageable phases.

కంపైలర్‌ను రూపొందించడంలో పనిని నిర్వహించదగిన దశలుగా విభజించడం ఉంటుంది.


Data flow analysis is a key technique used in compiler optimization.

కంపైలర్ ఆప్టిమైజేషన్‌లో డేటా ఫ్లో విశ్లేషణ ఒక ముఖ్యమైన సాంకేతికత.


This is a technical document about lexical analysis.

ఇది శబ్ద విశ్లేషణ గురించి ఒక సాంకేతిక పత్రం.


The DFA constructed from the NFA has four states.

NFA నుండి నిర్మించబడిన DFA నాలుగు స్థితులను కలిగి ఉంది.


Minimization of DFAs is an important concept in compiler design.

కంపైలర్ రూపకల్పనలో DFAల కనిష్టీకరణ ఒక ముఖ్యమైన భావన.


Lexical analysis is the first phase of a compiler.

శబ్ద విశ్లేషణ అనేది కంపైలర్ యొక్క మొదటి దశ.


అల్గారిథం DFAని తగ్గిస్తుంది.


We can decide equivalence of regular expressions by converting both to minimal DFAs.

రెగ్యులర్ ఎక్స్ప్రెషన్ల సమానత్వాన్ని రెండింటినీ కనిష్ట DFAsగా మార్చడం ద్వారా నిర్ణయించవచ్చు.


A dead state is a state from which no accepting state can be reached.

ఒక డెడ్ స్టేట్ అనేది స్వీకరించే స్థితికి చేరుకోలేని స్థితి.


Lexer generators create lexers from token definitions.

లెగ్జర్ జనరేటర్లు టోకెన్ నిర్వచనాల నుండి లెగ్జర్లను సృష్టిస్తాయి.


The principle of the longest match is used.

అత్యంత పొడవైన సరిపోలిక సూత్రం ఉపయోగించబడుతుంది.


The lexer must cut the input into tokens.

లెగ్జర్ ఇన్పుట్ను టోకెన్లుగా విభజించాలి.


సంయుక్త NFA DFAగా మార్చబడుతుంది.


This happens rarely when we use regular expressions.

రెగ్యులర్ ఎక్స్ప్రెషన్లను ఉపయోగించినప్పుడు ఇది చాలా అరుదుగా జరుగుతుంది.


ఒక DFA ని k * |v| సమయంలో అమలు చేయవచ్చు.


We start with two groups: the set of accepting states and the set of non-accepting states.

మేము రెండు సమూహాలతో ప్రారంభిస్తాము: అంగీకరించే స్థితుల సమితి మరియు అంగీకరించని స్థితుల సమితి.


సమూహాలు కనిష్ట DFAని ఏర్పరుస్తాయి.


The algorithm will treat these differently.

అల్గారిథం వీటిని భిన్నంగా పరిగణిస్తుంది.


The lexer has to distinguish between several different types of tokens.

లెగ్జర్ అనేక రకాల టోకెన్ల మధ్య వ్యత్యాసాన్ని గుర్తించాలి.


Each of these are described by its own regular expression.

వీటిలో ప్రతి ఒక్కటి దాని స్వంత రెగ్యులర్ ఎక్స్ప్రెషన్ ద్వారా వివరించబడింది.


The string 'if17' can be split in many different ways.

'if17' అనే స్ట్రింగ్ను అనేక విభిన్న మార్గాల్లో విభజించవచ్చు.


If no prefix of the input string forms a valid token, a lexical error has occurred.

ఇన్పుట్ స్ట్రింగ్ యొక్క పూర్వపదం చెల్లుబాటు అయ్యే టోకెన్ను ఏర్పరచకపోతే, ఒక శబ్ద లోపం సంభవించింది.


The program will compile the code and generate an executable file.

ప్రోగ్రామ్ కోడ్‌ను కంపైల్ చేసి ఎగ్జిక్యూటబుల్ ఫైల్‌ను ఉత్పత్తి చేస్తుంది.


Please provide your name and contact information.

దయచేసి మీ పేరు మరియు సంప్రదింపు వివరాలను అందించండి.


The company announced a new product launch next month.

కంపెనీ వచ్చే నెలలో కొత్త ఉత్పత్తిని ప్రారంభించనున్నట్లు ప్రకటించింది.


He is a very talented musician and composer.

అతను చాలా ప్రతిభావంతుడైన సంగీత విద్వాంసుడు మరియు స్వరకర్త.


The weather forecast predicts heavy rain for tomorrow.

రేపు భారీ వర్షాలు కురుస్తాయని వాతావరణ సూచన చెబుతోంది.


Could you please repeat that, I didn't understand.

దయచేసి మళ్ళీ చెప్పగలరా, నాకు అర్థం కాలేదు.


The algorithm efficiently sorts the data.

అల్గారిథం డేటాను సమర్థవంతంగా క్రమబద్ధీకరిస్తుంది.


ఆమె డాక్టర్ అవ్వడానికి చదువుతోంది.


The economic situation is improving gradually.

ఆర్థిక పరిస్థితి క్రమంగా మెరుగుపడుతోంది.


The research paper explores the impact of climate change.

పరిశోధనా పత్రం వాతావరణ మార్పుల ప్రభావాన్ని వివరిస్తుంది.


The software update includes several bug fixes.

సాఫ్ట్‌వేర్ అప్‌డేట్‌లో అనేక బగ్ పరిష్కారాలు ఉన్నాయి.


He is known for his honesty and integrity.

అతను తన నిజాయితీ మరియు సమగ్రతకు ప్రసిద్ధి చెందాడు.


The conference will be held in the city center.

సమావేశం నగర కేంద్రంలో జరుగుతుంది.


The complex equation requires advanced mathematical skills.

సంక్లిష్ట సమీకరణానికి అధునాతన గణిత నైపుణ్యాలు అవసరం.


The artist's paintings are displayed in a prestigious gallery.

కళాకారుడి చిత్రాలు ప్రతిష్టాత్మకమైన గ్యాలరీలో ప్రదర్శించబడతాయి.


The government is implementing new policies to boost the economy.

ఆర్థిక వ్యవస్థను ప్రోత్సహించడానికి ప్రభుత్వం కొత్త విధానాలను అమలు చేస్తోంది.


The ancient civilization left behind many mysteries.

పురాతన నాగరికత ఎన్నో రహస్యాలను వదిలి వెళ్ళింది.


The project requires a team of skilled professionals.

ప్రాజెక్ట్ నైపుణ్యం కలిగిన నిపుణుల బృందాన్ని కోరుతుంది.


The detective solved the case using logical reasoning.

డిటెక్టివ్ తార్కిక కారణాలను ఉపయోగించి కేసును పరిష్కరించాడు.


The company's stock price has increased significantly.

కంపెనీ షేరు ధర గణనీయంగా పెరిగింది.


The compiler translates the program into an intermediate language.

కంపైలర్ ప్రోగ్రామ్‌ను మధ్యంతర భాషలోకి అనువదిస్తుంది.


Lexical analysis is the first phase of compilation.

శబ్ద విశ్లేషణ అనేది సంకలనంలో మొదటి దశ.


Interpreters execute code directly, without creating a separate executable file.

ఇంటర్‌ప్రెటర్లు ప్రత్యేక ఎగ్జిక్యూటబుల్ ఫైల్‌ను సృష్టించకుండా నేరుగా కోడ్‌ను అమలు చేస్తాయి.


Regular expressions are used to define tokens.

టోకెన్‌లను నిర్వచించడానికి రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగిస్తారు.


A compiler is a program that translates source code into machine code.

కంపైలర్ అనేది సోర్స్ కోడ్‌ను మెషిన్ కోడ్‌గా అనువదించే ఒక ప్రోగ్రామ్.


The frontend of a compiler handles lexical analysis and parsing.

కంపైలర్ యొక్క ఫ్రంట్‌ఎండ్ శబ్ద విశ్లేషణ మరియు పార్సింగ్‌ను నిర్వహిస్తుంది.


Understanding compilers helps programmers write more efficient code.

కంపైలర్‌లను అర్థం చేసుకోవడం వల్ల ప్రోగ్రామర్‌లు మరింత సమర్థవంతమైన కోడ్‌ను రాయడానికి సహాయపడుతుంది.


Domain-specific languages are often compiled.

డొమైన్-నిర్దిష్ట భాషలు తరచుగా కంపైల్ చేయబడతాయి.


The book discusses lexical analysis and syntax analysis.

పుస్తకం శబ్ద విశ్లేషణ మరియు సింటాక్స్ విశ్లేషణ గురించి చర్చిస్తుంది.


Assembly and linking are typically done by programs supplied by the machine or operating system vendor.

అసెంబ్లీ మరియు లింకింగ్ సాధారణంగా మెషిన్ లేదా ఆపరేటింగ్ సిస్టమ్ విక్రేత అందించిన ప్రోగ్రామ్‌ల ద్వారా చేయబడతాయి.


Interpreters are often used where speed is not critical.

వేగం చాలా ముఖ్యమైనది కానప్పుడు ఇంటర్‌ప్రెటర్లను తరచుగా ఉపయోగిస్తారు.


The compiler course is a core subject in computer science.

కంపైలర్ కోర్సు కంప్యూటర్ సైన్స్‌లో ఒక ప్రధాన సబ్జెక్ట్.


ఒక మంచి కళాకారుడు తన పనిముట్లను తెలుసుకోవాలి.


The techniques used in compiler construction are useful for other purposes.

కంపైలర్ నిర్మాణంలో ఉపయోగించే పద్ధతులు ఇతర ప్రయోజనాల కోసం ఉపయోగపడతాయి.


Lexical analysis divides the input text into tokens.

శబ్ద విశ్లేషణ ఇన్‌పుట్ టెక్స్ట్ ను టోకెన్‌లుగా విభజిస్తుంది.


The syntax tree is processed directly to evaluate expressions.

వ్యక్తీకరణలను అంచనా వేయడానికి సింటాక్స్ ట్రీ నేరుగా ప్రాసెస్ చేయబడుతుంది.


పుస్తకం అంతరాన్ని తగ్గించే లక్ష్యంతో ఉంది.


The author wishes to thank all people who have been helpful.

సహాయం చేసిన వారందరికీ రచయిత కృతజ్ఞతలు తెలుపుతున్నాడు.


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

శబ్ద విశ్లేషణ యొక్క ప్రధాన ఉద్దేశ్యం తదుపరి సింటాక్స్ విశ్లేషణ దశకు జీవితాన్ని సులభతరం చేయడం.


Each phase establishes stronger invariants.

ప్రతి దశ బలమైన స్థిరాలను ఏర్పరుస్తుంది.


The program checks the input for validity.

ప్రోగ్రామ్ ఇన్పుట్ యొక్క చెల్లుబాటును తనిఖీ చేస్తుంది.


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 పునరావృత అవరోహణ పార్సర్ కోసం సూడో-కోడ్‌ను చూపుతుంది.


We have constructed this program by the following process.

మేము ఈ ప్రోగ్రామ్‌ను ఈ క్రింది ప్రక్రియ ద్వారా నిర్మించాము.


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

మేము మొదట ఒక ఉత్పత్తి T' → T$ ని జోడించాము.


We have added a check on the next input symbol anyway.

మేము ఏమైనా తదుపరి ఇన్పుట్ గుర్తుపై ఒక తనిఖీని జోడించాము.


ఇది parseT’ ఫంక్షన్‌లో చూపబడింది.


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) లోని చిహ్నాలపై కూడా ఎంచుకోవాలి.


On all other symbols we report an error.

ఇతర చిహ్నాలన్నింటిలోనూ మేము ఒక లోపాన్ని నివేదిస్తాము.


The function match takes as argument a symbol.

match ఫంక్షన్ ఒక గుర్తును వాదనగా తీసుకుంటుంది.


If they are equal, the following symbol is read into the variable next.

అవి సమానంగా ఉంటే, తదుపరి గుర్తు next వేరియబుల్‌లోకి చదవబడుతుంది.


The program in figure 3.16 only checks if the input is valid.

చిత్రం 3.16 లోని ప్రోగ్రామ్ ఇన్పుట్ చెల్లుబాటు అవుతుందో లేదో మాత్రమే తనిఖీ చేస్తుంది.


It can easily be extended to construct a syntax tree.

దీనిని సింటాక్స్ చెట్టును నిర్మించడానికి సులభంగా విస్తరించవచ్చు.


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.

ఒక సాధారణ నాన్-రీకర్సివ్ ప్రోగ్రామ్ పార్సింగ్ చేయడానికి ఈ టేబుల్ మరియు ఒక స్టాక్‌ను ఉపయోగిస్తుంది.


The syntax tree adds structure to the string that it derives.

సింటాక్స్ ట్రీ అది పొందిన స్ట్రింగ్‌కు నిర్మాణం జోడిస్తుంది.


Where lexical analysis splits the input into tokens, the purpose of syntax analysis is to recombine these tokens.

పదాల విశ్లేషణ ఇన్‌పుట్‌ను టోకెన్‌లుగా విభజిస్తే, సింటాక్స్ విశ్లేషణ యొక్క ఉద్దేశ్యం ఏమిటంటే ఈ టోకెన్‌లను తిరిగి కలపడం.


A simple grammar for statements might look like grammar 3.3, which refers to the Ex p nonterminal.

ప్రకటనల కోసం ఒక సాధారణ వ్యాకరణం వ్యాకరణం 3.3 లాగా ఉండవచ్చు, ఇది Ex p నాన్ టెర్మినల్‌ను సూచిస్తుంది.


Each syntactic category is denoted by a main nonterminal.

ప్రతి సింటాక్టిక్ వర్గాన్ని ఒక ప్రధాన నాన్ టెర్మినల్ ద్వారా సూచిస్తారు.


We can define a grammar equivalent to the regular expression a * by the two productions.

రెండు ఉత్పత్తుల ద్వారా రెగ్యులర్ ఎక్స్‌ప్రెషన్ a * కి సమానమైన వ్యాకరణాన్ని మనం నిర్వచించవచ్చు.


Context-free grammars are capable of expressing much more complex languages.

సందర్భ రహిత వ్యాకరణాలు చాలా సంక్లిష్టమైన భాషలను వ్యక్తీకరించగలవు.


The leaves of this tree are the tokens found by the lexical analysis.

ఈ చెట్టు యొక్క ఆకులు పదాల విశ్లేషణ ద్వారా కనుగొనబడిన టోకెన్‌లు.


The second production ensures that the as and bs are paired symmetrically.

రెండవ ఉత్పత్తి as మరియు bs సమరూపంగా జత చేయబడిందని నిర్ధారిస్తుంది.


This process is called parser generation.

ఈ ప్రక్రియను పార్సర్ ఉత్పత్తి అంటారు.


We will look at structure in sections 3.3.1 and 3.4.

విభాగం 3.3.1 మరియు 3.4 లలో మనం నిర్మాణం గురించి చూస్తాము.


వ్యాకరణం యొక్క ప్రారంభ చిహ్నం.


A language is defined over some alphabet.

ఒక భాష కొన్ని అక్షరమాలపై నిర్వచించబడింది.


The intended meaning of this notation is to say that the set denoted by N contains strings.

ఈ సంజ్ఞామానం యొక్క ఉద్దేశించిన అర్థం ఏమిటంటే N ద్వారా సూచించబడిన సమితి స్ట్రింగ్‌లను కలిగి ఉంటుంది.


Productions with empty right-hand sides are called empty productions.

ఖాళీ కుడి చేతి వైపులా ఉన్న ఉత్పత్తులను ఖాళీ ఉత్పత్తులు అంటారు.


So far, we have not described any set that could not just as well have been described using regular expressions.

ఇప్పటివరకు, రెగ్యులర్ ఎక్స్‌ప్రెషన్‌లను ఉపయోగించి వివరించలేని ఏ సమితిని మేము వివరించలేదు.


When several nonterminals are used, we must make it clear which of these is the start symbol.

అనేక నాన్ టెర్మినల్స్ ఉపయోగించినప్పుడు, వీటిలో ఏది ప్రారంభ చిహ్నమో మనం స్పష్టం చేయాలి.


ఉత్పత్తి సంబంధం ప్రతిబింబిస్తుంది.


A derivation that always rewrites the leftmost nonterminal is called a leftmost derivation.

ఎల్లప్పుడూ ఎడమవైపున ఉన్న నాన్ టెర్మినల్‌ను తిరిగి రాసే ఉత్పత్తిని ఎడమవైపున ఉన్న ఉత్పత్తి అంటారు.


If a grammar permits several different syntax trees for some strings we call the grammar ambiguous.

ఒక వ్యాకరణం కొన్ని స్ట్రింగ్‌ల కోసం అనేక విభిన్న సింటాక్స్ చెట్లను అనుమతిస్తే, మేము వ్యాకరణాన్ని అస్పష్టంగా పిలుస్తాము.


In most cases, an ambiguous grammar can be rewritten to an unambiguous grammar.

చాలా సందర్భాల్లో, అస్పష్టమైన వ్యాకరణాన్ని స్పష్టమైన వ్యాకరణానికి తిరిగి వ్రాయవచ్చు.


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, some of the subsequent errors may really be spurious errors caused by lexical error(s).

మళ్ళీ, తదుపరి లోపాలలో కొన్ని నిజంగా శబ్ద లోపం(ల) వలన కలిగే నకిలీ లోపాలు కావచ్చు.


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 arenotin the set.

అదనంగా, కొన్ని శబ్ద విశ్లేషణకారి జనరేటర్లు వివిధ మార్గాల్లో రెగ్యులర్ ఎక్స్ప్రెషన్లను విస్తరిస్తారు, ఉదాహరణకు, సెట్లో లేని అక్షరాలను జాబితా చేయడం ద్వారా అక్షరాల సమితిని పేర్కొనడానికి అనుమతిస్తుంది.


The input to the lexer generator will normally contain a list of regular expres- sions 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 num- ber token, the name of an identifier token and, perhaps, the position of the token in the input file.

చర్య వినియోగదారునికి (ఉదాహరణకు, పార్సర్) ఏమి పంపబడుతుందో వివరిస్తుంది, సాధారణంగా టోకెన్ డేటా రకం నుండి ఒక మూలకం, ఇది టోకెన్ రకాన్ని (NUM, ID, మొదలైనవి) మరియు కొన్నిసార్లు సంఖ్యా టోకెన్ విలువ, గుర్తింపు టోకెన్ పేరు మరియు బహుశా, ఇన్పుట్ ఫైల్లోని టోకెన్ స్థానం వంటి అదనపు సమాచారాన్ని వివరిస్తుంది.


Normally, the lexer generator requires white-space and comments to be de- fined 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 individu- ally 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.

క్లిష్టమైన శబ్ద విశ్లేషణ చర్యల యొక్క మరొక ఉపయోగం నెస్ట్ చేసిన వ్యాఖ్యల కోసం.


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ని ఏర్పరుస్తాయి.


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

ఇప్పుడు మనం విభాగం 2.5లో చూపిన ఉపసమితి నిర్మాణాన్ని ఉపయోగించి ఈ NFAని DFAగా మార్చాలి.


Instead of showing the resulting DFA graphically, we construct a table where transitions on terminals are shown asshiftactions and tran- sitions on nonterminals asgoactions.

ఫలిత DFAని గ్రాఫికల్‌గా చూపడానికి బదులుగా, టెర్మినల్స్‌పై పరివర్తనలు షిఫ్ట్ చర్యలుగా మరియు నాన్-టెర్మినల్స్‌పై పరివర్తనలు గో చర్యలుగా చూపబడే ఒక పట్టికను నిర్మిస్తాము.


This will make the table look similar to fig- ure 3.22, except that noreduceoracceptactions are present yet.

ఇది పట్టికను పటం 3.22 వలె కనిపించేలా చేస్తుంది, అయితే ఇంకా ఎటువంటి తగ్గింపు లేదా అంగీకార చర్యలు లేవు.


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

పటం 3.28, 3.27లో ఎప్సిలాన్-పరివర్తనలను పటం 3.26కి జోడించడం ద్వారా తయారు చేయబడిన NFA నుండి నిర్మించబడిన DFAని చూపుతుంది.


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 addingreduceand acceptactions, but once this is done, we will not need them anymore, so we can remove them from the final table.

తగ్గింపు మరియు అంగీకార చర్యలను జోడించడానికి మనకు ఇవి క్రింద అవసరం, కానీ ఇది పూర్తయిన తర్వాత, అవి ఇకపై అవసరం లేదు, కాబట్టి వాటిని తుది పట్టిక నుండి తీసివేయవచ్చు.


To addreduceandacceptactions, we first need to compute theFOLLOWsets for each nonterminal, as described in section 3.10.

తగ్గింపు మరియు అంగీకార చర్యలను జోడించడానికి, మనం మొదట విభాగం 3.10లో వివరించిన విధంగా, ప్రతి నాన్-టెర్మినల్ కోసం FOLLOW సమితులను లెక్కించాలి.


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

FOL-LOWని లెక్కించే ఉద్దేశ్యంతో, మనం మరొక అదనపు ప్రారంభ ఉత్పత్తిని జోడిస్తాము: 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 addreduceactions by the following rule: If a DFA statescontains the accepting NFA state for a productionp:N→α, we addreduce pas action toson 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 inFOLLOW(N).

అప్పుడు మనం ఈ నియమం ద్వారా తగ్గింపు చర్యలను జోడిస్తాము: ఒక DFA రాష్ట్రంలో ఉత్పత్తి p:N→α కోసం అంగీకార NFA రాష్ట్రం ఉంటే, మనం 94వ అధ్యాయం 3. సింటాక్స్ విశ్లేషణ DFANFATransitions రాష్ట్రాలు a b cTR 0A, C, E, I, Js3s4g1g2 1B 2D 3F, C, E, I, Js3s4g5g2 4K, I, Js4g6 5Gs7 6L 7H పటం 3.28: వ్యాకరణం 3.9లోని SLR DFAలోని అన్ని చిహ్నాలకు FOLLOW(N)లో తగ్గింపు p చర్యను జోడిస్తాము.


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

ఉత్పత్తి 0 (NFAని నిర్మించడానికి ముందు జోడించిన అదనపు ప్రారంభ ఉత్పత్తి)పై తగ్గింపును అంగీకారంగా వ్రాయబడుతుంది.


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

పటం 3.28లో, రాష్ట్రం 0 ఉత్పత్తి 3ని అంగీకరించే NFA రాష్ట్రాన్ని కలిగి ఉంది.


Hence, we add r3 as actions at the symbolscand $ (as these are inFOLLOW(R)).

అందువల్ల, మనం చిహ్నాలు c మరియు $ వద్ద r3ని చర్యలుగా జోడిస్తాము (ఎందుకంటే ఇవి FOLLOW(R)లో ఉన్నాయి).


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

రాష్ట్రం 1 ఉత్పత్తి 0ని అంగీకరించే NFA రాష్ట్రాన్ని కలిగి ఉంది.


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

మనం దీన్ని $ గుర్తు వద్ద జోడిస్తాము (FOLLOW(T ′ )).


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

పైన పేర్కొన్న విధంగా, ఇది అంగీకారంగా వ్రాయబడింది (సంక్షిప్తంగా “a”).


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

అదే విధంగా, మనం రాష్ట్రం 3, 4, 6 మరియు 7కి తగ్గింపు చర్యలను జోడిస్తాము.


Hence, the productions for a nonterminal corresponding to a particular precedence level refers only to nonterminals that correspond to the same or higher precedence levels, un- less parentheses or similar bracketing constructs disambiguate the use of these.

అందువల్ల, ఒక నిర్దిష్ట ప్రాధాన్యత స్థాయికి సంబంధించిన ఒక నాన్ టెర్మినల్ కోసం ఉత్పత్తులు, అదే లేదా అంతకంటే ఎక్కువ ప్రాధాన్యత స్థాయిలకు సంబంధించిన నాన్ టెర్మినల్స్‌ను మాత్రమే సూచిస్తాయి, అయితే బ్రాకెట్‌లు లేదా ఇలాంటి బ్రాకెటింగ్ నిర్మాణాలు వీటిని ఉపయోగించడాన్ని స్పష్టం చేస్తాయి.


Grammar 3.11 shows how these rules are used to make an unambiguous version of grammar 3.2.

వ్యాకరణం 3.11 ఈ నియమాలను వ్యాకరణం 3.2 యొక్క స్పష్టమైన సంస్కరణను రూపొందించడానికి ఎలా ఉపయోగిస్తారో చూపిస్తుంది.


Figure 3.12 show the syntax tree for2+3*4using this grammar.

ఈ వ్యాకరణాన్ని ఉపయోగించి 2+3*4 కోసం సింటాక్స్ ట్రీని చిత్రం 3.12 చూపుతుంది.


సూచించిన వ్యాయామాలు: 3.6.


3.5 Other sources of ambiguity Most of the potential ambiguity in grammars for programming languages comes from expression syntax and can be handled by exploiting precedence rules as shown in section 3.4.

3.5 అస్పష్టత యొక్క ఇతర మూలాలు ప్రోగ్రామింగ్ భాషల కోసం వ్యాకరణాలలో చాలా సంభావ్య అస్పష్టత వ్యక్తీకరణ సింటాక్స్ నుండి వస్తుంది మరియు విభాగం 3.4 లో చూపిన విధంగా ప్రాధాన్యత నియమాలను ఉపయోగించడం ద్వారా నిర్వహించవచ్చు.


Another classical example of ambiguity is the “dangling-else” prob- lem.

అస్పష్టతకు మరొక క్లాసికల్ ఉదాహరణ “డాంగ్లింగ్-ఎల్‌స్” సమస్య.


Imperative languages like Pascal or C often let the else-part of a conditional be optional, like shown in grammar 3.3.

పాస్కల్ లేదా సి వంటి ఆజ్ఞాపక భాషలు సాధారణంగా షరతులతో కూడిన ఎల్స్-భాగాన్ని ఐచ్ఛికంగా అనుమతిస్తాయి, వ్యాకరణం 3.3 లో చూపిన విధంగా.


The problem is that it is not clear how to 3.5. OTHER SOURCES OF AMBIGUITY67 Ex p 0 0 @ @ Ex p + Ex p2 0 0 @ @ Ex p2Ex p2 * Ex p3 Ex p3Ex p3 4 2 3 Figure 3.12: Syntax tree for2+3*4using grammar 3.11 parse, for example, if p then if q then s1 else s2 According to the grammar, theelsecan equally well match eitherif.

సమస్య ఏమిటంటే, ఎలా అర్థం చేసుకోవాలో స్పష్టంగా లేదు 3.5. అస్పష్టత యొక్క ఇతర మూలాలు 67 ఉదాహరణ p 0 0 @ @ ఉదాహరణ p + ఉదాహరణ p2 0 0 @ @ ఉదాహరణ p2Ex p2 * ఉదాహరణ p3 ఉదాహరణ p3Ex p3 4 2 3 చిత్రం 3.12: వ్యాకరణం 3.11ని ఉపయోగించి 2+3*4 కోసం సింటాక్స్ ట్రీ, ఉదాహరణకు, p అయితే q అయితే s1 else s2 అయితే వ్యాకరణం ప్రకారం, ఎల్స్ కూడా ఏదైనా సరిపోతుంది.


The usual convention is that anelsematches the closest not previously matchedif, which, in the example, will make theelsematch the secondif.

సాధారణ సమావేశం ఏమిటంటే, ఎల్స్ మునుపు సరిపోలని సమీపంలోని వాటితో సరిపోలుతుంది, ఇది ఉదాహరణలో, ఎల్స్ రెండవ వాటితో సరిపోలుస్తుంది.


How do we make this clear in the grammar?

వ్యాకరణంలో దీన్ని ఎలా స్పష్టం చేయాలి?


We can treatif,thenandelse as a kind of right-associative operators, as this would make them group to the right, making anif-thenmatch the closestelse.

మేము if, then మరియు elseలను ఒక రకమైన కుడి-అసోసియేటివ్ ఆపరేటర్లుగా పరిగణించవచ్చు, ఎందుకంటే ఇది వాటిని కుడివైపుకు సమూహపరుస్తుంది, if-then సమీపంలోని వాటితో సరిపోలుతుంది.


However, the grammar transforma- tions shown in section 3.4 can not directly be applied to grammar 3.3, as the pro- ductions for conditionals do not have the right form.

అయితే, విభాగం 3.4 లో చూపిన వ్యాకరణ మార్పులను నేరుగా వ్యాకరణం 3.3కి వర్తింపజేయలేము, ఎందుకంటే షరతుల కోసం ఉత్పత్తులు సరైన రూపంలో లేవు.


Instead we use the following observation: When anifand anelsematch, all ifs that occur between these must have matchingelses.

బదులుగా, మేము ఈ క్రింది పరిశీలనను ఉపయోగిస్తాము: ఒక if మరియు ఒక else సరిపోలినప్పుడు, వీటి మధ్య సంభవించే అన్ని ifs సరిపోలే elseలను కలిగి ఉండాలి.


This can easily be proven by assuming otherwise and concluding that this leads to a contradiction.

దీనిని ఇతరత్రా ఊహించడం ద్వారా మరియు ఇది ఒక వ్యతిరేకతకు దారి తీస్తుందని నిర్ధారించడం ద్వారా సులభంగా నిరూపించవచ్చు.


Hence, we make two nonterminals: One for matched (i.e.withelse-part) conditionals and one for unmatched (i.e.withoutelse-part) conditionals.

అందువల్ల, మేము రెండు నాన్ టెర్మినల్స్‌ను తయారు చేస్తాము: ఒకటి సరిపోలిన (అంటే ఎల్స్-భాగంతో) షరతుల కోసం మరియు ఒకటి సరిపోలని (అంటే ఎల్స్-భాగం లేకుండా) షరతుల కోసం.


ఫలితం వ్యాకరణం 3.13లో చూపబడింది.


This grammar also resolves the associativity of semicolon (right) and the precedence ofifover semicolon.

ఈ వ్యాకరణం సెమీకోలన్ (కుడి) యొక్క అనుబంధాన్ని మరియు సెమీకోలన్ పై if యొక్క ప్రాధాన్యతను కూడా పరిష్కరిస్తుంది.


An alternative to rewriting grammars to resolve ambiguity is to use an ambigu- ous grammar and resolve conflicts by using precedence rules during parsing.

అస్పష్టతను పరిష్కరించడానికి వ్యాకరణాలను తిరిగి రాయడానికి ఒక ప్రత్యామ్నాయం ఏమిటంటే, అస్పష్టమైన వ్యాకరణాన్ని ఉపయోగించడం మరియు పార్సింగ్ సమయంలో ప్రాధాన్యత నియమాలను ఉపయోగించడం ద్వారా వివాదాలను పరిష్కరించడం.


We shall look into this in section 3.16.

మేము దీన్ని విభాగం 3.16లో పరిశీలిస్తాము.


All cases of ambiguity must be treated carefully: It is not enough that we elim- inate ambiguity, we must do so in a way that results in the desired structure: The structure of arithmetic expressions is significant, and it makes a difference to which ifanelseis matched.

అస్పష్టత యొక్క అన్ని కేసులను జాగ్రత్తగా పరిగణించాలి: అస్పష్టతను తొలగించడం సరిపోదు, మనం కోరుకున్న నిర్మాణానికి దారితీసే విధంగా అలా చేయాలి: అంకగణిత వ్యక్తీకరణల నిర్మాణం చాలా ముఖ్యమైనది మరియు ఏ ifanelse సరిపోతుందో అది ఒక వ్యత్యాసాన్ని కలిగిస్తుంది.


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

సహజ భాషలను వివరించడానికి సందర్భ రహిత వ్యాకరణాలను మొదట ప్రతిపాదించారు.


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

సందర్భ రహిత వ్యాకరణాలు వాస్తవానికి సహజ భాషలను వివరించడానికి చాలా బలహీనంగా ఉన్నాయి.


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

కంపైలర్‌కు పేర్లను మరియు అవి దేనికి బంధించబడ్డాయో వాటిని ట్రాక్ చేయాలి.


This is typically done using a symbol table.

ఇది సాధారణంగా సింబల్ టేబుల్‌ని ఉపయోగించి చేయబడుతుంది.


We need to be able to bind a name to a piece of information.

మేము ఒక పేరును సమాచారం యొక్క భాగానికి బంధించగలగాలి.


We need to be able to enter a new scope.

మేము కొత్త స్కోప్‌ను నమోదు చేయగలగాలి.


మేము స్కోప్ నుండి నిష్క్రమించగలగాలి.


A persistent data structure has the property that no operation on the structure will destroy it.

ఒక నిరంతర డేటా నిర్మాణం నిర్మాణంపై ఎటువంటి ఆపరేషన్ దానిని నాశనం చేయని లక్షణాన్ని కలిగి ఉంటుంది.


In the imperative approach, only one copy of the symbol table exists.

ఆవశ్యక విధానంలో, సింబల్ టేబుల్ యొక్క ఒకే కాపీ మాత్రమే ఉంది.


Lookup is done by linear search, so the worst-case time for lookup is proportional to the size of the symbol table.

లీనియర్ శోధన ద్వారా లుకప్ చేయబడుతుంది, కాబట్టి లుకప్ కోసం అధ్వాన్న సమయం సింబల్ టేబుల్ పరిమాణానికి అనులోమానుపాతంలో ఉంటుంది.


A common solution to this problem is hashing.

ఈ సమస్యకు సాధారణ పరిష్కారం హాషింగ్.


Names are hashed into integers, which are used to index an array.

పేర్లు పూర్ణాంకాలలోకి హాష్ చేయబడతాయి, ఇవి శ్రేణిని సూచించడానికి ఉపయోగించబడతాయి.


In some languages a variable and a function in the same scope may have the same name.

కొన్ని భాషలలో ఒకే స్కోప్‌లోని వేరియబుల్ మరియు ఫంక్షన్ ఒకే పేరును కలిగి ఉండవచ్చు.


We say that functions and variables have separate name spaces.

ఫంక్షన్లు మరియు వేరియబుల్స్ ప్రత్యేకమైన పేరు స్థలాలను కలిగి ఉన్నాయని మేము చెబుతాము.


These languages have a shared name space for variables and functions.

ఈ భాషలు వేరియబుల్స్ మరియు ఫంక్షన్ల కోసం భాగస్వామ్య పేరు స్థలాన్ని కలిగి ఉన్నాయి.


Separate name spaces are easily implemented using one symbol table per name space.

ఒక పేరు స్థలానికి ఒక సింబల్ టేబుల్‌ని ఉపయోగించి ప్రత్యేక పేరు స్థలాలను సులభంగా అమలు చేయవచ్చు.


After lexing and parsing, we have the abstract syntax tree of a program as a data structure in memory.

లెక్సింగ్ మరియు పార్సింగ్ తర్వాత, మనకు మెమరీలో డేటా స్ట్రక్చర్‌గా ప్రోగ్రామ్ యొక్క అబ్‌స్ట్రాక్ట్ సింటాక్స్ ట్రీ ఉంది.


కానీ ఒక ప్రోగ్రామ్‌ను అమలు చేయాలి.


Each such named object will have a declaration.

అటువంటి ప్రతి పేరున్న వస్తువుకు ప్రకటన ఉంటుంది.


దీనిని బైండింగ్ అంటారు.


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.

మేము వ్యక్తీకరణలో వేరియబుల్స్ యొక్క విలువలను చొప్పిస్తాము మరియు దానిని కొంచెం కొంచెం అంచనా వేస్తాము.


Starting with the innermost parentheses and moving out until we have the result.

అంతర్గత బ్రాకెట్‌లతో ప్రారంభించి, ఫలితం వచ్చే వరకు బయటకు వెళ్లడం.


We can then repeat the process with other values for the variables.

అప్పుడు మనం వేరియబుల్స్ కోసం ఇతర విలువలతో ప్రక్రియను పునరావృతం చేయవచ్చు.


అయితే, కొన్ని తేడాలు ఉన్నాయి.


Where a human being will copy the text of the formula with variables replaced by values.

ఒక మానవుడు వేరియబుల్స్‌తో సూత్రం యొక్క వచనాన్ని విలువలతో భర్తీ చేస్తాడు.


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.

ప్రతి ఫంక్షన్ వాదనలుగా అబ్‌స్ట్రాక్ట్ సింటాక్స్ ట్రీని తీసుకుంటుంది.


The functions can be implemented in any language that we already have an implementation of.

ఫంక్షన్లను మనం ఇప్పటికే అమలు చేసిన ఏదైనా భాషలో అమలు చేయవచ్చు.


We will use a small language to show the principles of interpretation.

వివరణ సూత్రాలను చూపించడానికి మేము ఒక చిన్న భాషను ఉపయోగిస్తాము.


సింటాక్స్ వ్యాకరణం 5.1లో ఇవ్వబడింది.


The language is a first-order functional language with recursive definitions.

ఈ భాష పునరావృత నిర్వచనాలతో కూడిన మొదటి-క్రమ ఫంక్షనల్ భాష.


The compiler uses an intermediate language as a stepping-stone.

కంపైలర్ ఒక మధ్యంతర భాషను ఒక మెట్టుగా ఉపయోగిస్తుంది.


Many compilers use a medium-level language.

అనేక కంపైలర్లు మధ్యస్థాయి భాషను ఉపయోగిస్తారు.


Such stepping-stone languages are called intermediate code.

అటువంటి మెట్టు భాషలను మధ్యంతర కోడ్ అంటారు.


Apart from structuring the compiler into smaller jobs, using an intermediate language has other advantages.

కంపైలర్‌ను చిన్న పనులుగా విభజించడంతో పాటు, మధ్యంతర భాషను ఉపయోగించడం వల్ల ఇతర ప్రయోజనాలు ఉన్నాయి.


If the compiler needs to generate code for several different machine-architectures, only one translation to intermediate code is needed.

కంపైలర్ అనేక విభిన్న యంత్ర-నిర్మాణాలకు కోడ్‌ను రూపొందించవలసి వస్తే, మధ్యంతర కోడ్‌కు ఒకే అనువాదం సరిపోతుంది.


Only the translation from intermediate code to machine language (i.e., the back-end) needs to be written in several versions.

మధ్యంతర కోడ్ నుండి మెషిన్ భాషలోకి అనువాదం (అంటే, బ్యాక్-ఎండ్) మాత్రమే అనేక వెర్షన్లలో వ్రాయవలసి ఉంటుంది.


If several high-level languages need to be compiled, only the translation to intermediate code need to be written for each language.

అనేక ఉన్నత-స్థాయి భాషలను కంపైల్ చేయవలసి వస్తే, ప్రతి భాష కోసం మధ్యంతర కోడ్‌కు అనువాదం మాత్రమే వ్రాయాలి.


They can all share the back-end, i.e., the translation from intermediate code to machine code.

అవన్నీ బ్యాక్-ఎండ్‌ను పంచుకోవచ్చు, అంటే, మధ్యంతర కోడ్ నుండి మెషిన్ కోడ్‌కు అనువాదం.


Instead of translating the intermediate language to machine code, it can be interpreted by a small program.

మధ్యంతర భాషను మెషిన్ కోడ్‌గా అనువదించడానికి బదులుగా, దానిని చిన్న ప్రోగ్రామ్ ద్వారా అర్థం చేసుకోవచ్చు.


The advantage of using an intermediate language is significant.

మధ్యంతర భాషను ఉపయోగించడం వల్ల కలిగే ప్రయోజనం చాలా ముఖ్యమైనది.


The final goal of a compiler is to get programs written in a high-level language to run on a computer.

కంపైలర్ యొక్క అంతిమ లక్ష్యం ఏమిటంటే, ఉన్నత-స్థాయి భాషలో వ్రాసిన ప్రోగ్రామ్‌లను కంప్యూటర్‌లో అమలు చేయడం.


This means that, eventually, the program will have to be expressed as machine code.

అంటే, చివరికి, ప్రోగ్రామ్‌ను మెషిన్ కోడ్‌గా వ్యక్తీకరించాలి.


The program will have to be expressed as machine code which can run on the computer.

కంప్యూటర్‌లో అమలు చేయగల మెషిన్ కోడ్‌గా ప్రోగ్రామ్‌ను వ్యక్తీకరించాలి.


This does not mean that we need to translate directly from the high-level abstract syntax to machine code.

దీని అర్థం ఏమిటంటే, మనం నేరుగా ఉన్నత-స్థాయి అబ్‌స్ట్రాక్ట్ సింటాక్స్ నుండి మెషిన్ కోడ్‌కు అనువదించాల్సిన అవసరం లేదు.


The advantage of using an intermediate language is that it simplifies the compilation process.

మధ్యంతర భాషను ఉపయోగించడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, ఇది కంపైలేషన్ ప్రక్రియను సరళీకృతం చేస్తుంది.


It can be interpreted by a small program written in machine code.

దీనిని మెషిన్ కోడ్‌లో వ్రాసిన చిన్న ప్రోగ్రామ్ ద్వారా అర్థం చేసుకోవచ్చు.


The intermediate language can be interpreted by a small program.

మధ్యంతర భాషను చిన్న ప్రోగ్రామ్ ద్వారా అర్థం చేసుకోవచ్చు.


The intermediate language can be interpreted by a program.

మధ్యంతర భాషను ఒక ప్రోగ్రామ్ ద్వారా అర్థం చేసుకోవచ్చు.


The intermediate language simplifies the compilation process.

మధ్యంతర భాష కంపైలేషన్ ప్రక్రియను సరళీకృతం చేస్తుంది.


The compiler's goal is to run high-level language programs on a computer.

కంపైలర్ యొక్క లక్ష్యం ఏమిటంటే, ఉన్నత-స్థాయి భాషా ప్రోగ్రామ్‌లను కంప్యూటర్‌లో అమలు చేయడం.


We then extend the translation function for conditions as follows:

అప్పుడు మనం షరతుల కోసం అనువాద ఫంక్షన్‌ను ఈ విధంగా విస్తరిస్తాము:


The rule for relational operators is now actually superfluous.

సంబంధిత ఆపరేటర్ల నియమం ఇప్పుడు వాస్తవానికి మిగులుగా ఉంది.


However, we can consider it an optimisation.

అయితే, మనం దానిని ఒక ఆప్టిమైజేషన్‌గా పరిగణించవచ్చు.


It will also be natural to keep it separate when we add sequential logical operators.

అనుక్రమిక తార్కిక ఆపరేటర్లను జోడించినప్పుడు దానిని వేరుగా ఉంచడం కూడా సహజంగా ఉంటుంది.


We will use the same names for sequential logical operators as C.

మేము C వలె అనుక్రమిక తార్కిక ఆపరేటర్ల కోసం అదే పేర్లను ఉపయోగిస్తాము.


Note that we allow an expression to be a condition as well as a condition to be an expression.

ఒక వ్యక్తీకరణ ఒక షరతుగా ఉండటానికి అలాగే ఒక షరతు ఒక వ్యక్తీకరణగా ఉండటానికి మేము అనుమతిస్తాము.


ఈ వ్యాకరణం చాలా అస్పష్టంగా ఉంది.


As before, we assume such ambiguity to be resolved by the parser before code generation.

ముందుగా చెప్పినట్లుగానే, కోడ్ ఉత్పత్తికి ముందు పార్సర్ ద్వారా అటువంటి అస్పష్టత పరిష్కరించబడుతుందని మేము భావిస్తున్నాము.


The revised translation functions for Ex p and Cond are shown in figure 7.8.

Ex p మరియు Cond కోసం సవరించిన అనువాద విధులు 7.8 చిత్రంలో చూపబడ్డాయి.


As expressions, true and false are the numbers 1 and 0.

వ్యక్తీకరణలుగా, నిజం మరియు తప్పు 1 మరియు 0 సంఖ్యలు.


A condition Cond is translated into code that chooses between two labels.

ఒక షరతు Cond రెండు లేబుల్‌ల మధ్య ఎంచుకునే కోడ్‌గా అనువదించబడుతుంది.


When we want to use a condition as an expression, we must convert this choice into a number.

ఒక షరతును వ్యక్తీకరణగా ఉపయోగించాలనుకున్నప్పుడు, మనం ఈ ఎంపికను ఒక సంఖ్యగా మార్చాలి.


We do this by first assuming that the condition is false and hence assign 0 to the target location.

మొదట షరతు తప్పు అని భావించడం ద్వారా మరియు లక్ష్య స్థానానికి 0 కేటాయించడం ద్వారా మేము దీన్ని చేస్తాము.


We could equally well have done things the other way around.

మనం కూడా విషయాలను మరొక విధంగా చేయవచ్చు.


It gets a bit more interesting in Trans Cond, where we translate conditions.

Trans Condలో ఇది కొంచెం ఆసక్తికరంగా ఉంటుంది, ఇక్కడ మనం షరతులను అనువదిస్తాము.


The constant true condition just generates a jump to the label for true conditions.

స్థిరమైన నిజమైన షరతు నిజమైన షరతుల కోసం లేబుల్‌కు జంప్‌ను మాత్రమే ఉత్పత్తి చేస్తుంది.


Logical negation generates no code by itself.

లాజికల్ నెగేషన్ దానికదే కోడ్‌ను ఉత్పత్తి చేయదు.


Sequential logical and is translated as follows:

అనుక్రమిక తార్కిక మరియు ఈ విధంగా అనువదించబడింది:


If the first operand is true, we jump directly to the label for true conditions without testing the second operand.

మొదటి ఆపరేండ్ నిజమైతే, రెండవ ఆపరేండ్‌ను పరీక్షించకుండానే మనం నేరుగా నిజమైన షరతుల కోసం లేబుల్‌కు వెళ్తాము.


Note that the translation functions now work even if binop and unop do not contain relational operators or logical negation.

binop మరియు unop సంబంధిత ఆపరేటర్లు లేదా తార్కిక తిరస్కరణను కలిగి లేనప్పటికీ అనువాద విధులు ఇప్పుడు పని చేస్తాయని గమనించండి.


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.

కంపైల్ చేయబడిన ప్రోగ్రామ్‌ను అన్ని యంత్రాల కోసం ఒకే మధ్యంతర రూపంలో పంపిణీ చేయవచ్చు.


The intermediate form may be more compact than machine code.

మధ్యంతర రూపం మెషిన్ కోడ్ కంటే మరింత కాంపాక్ట్‌గా ఉండవచ్చు.


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.

ప్రోగ్రామ్ అమలుకు ముందు లేదా సమయంలో మధ్యంతర కోడ్‌ను మెషిన్ కోడ్‌గా అనువదించడం ద్వారా కొంత వేగపు జరిమానాను తొలగించవచ్చు.


This hybrid form is called just-in-time compilation and is often used for executing the intermediate code for Java.

ఈ హైబ్రిడ్ రూపాన్ని జస్ట్-ఇన్-టైమ్ కంపైలేషన్ అంటారు మరియు జావా కోసం మధ్యంతర కోడ్‌ను అమలు చేయడానికి తరచుగా ఉపయోగిస్తారు.


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.

మధ్యంతర భాషను అర్థం చేసుకున్నప్పుడు ఈ విధానాలలో మొదటిది తరచుగా ఉపయోగించబడుతుంది.


When coarse-grained intermediate code is used, there is typically a fairly large number of different intermediate-code operations.

ముతక-ధాన్యం మధ్యంతర కోడ్‌ను ఉపయోగించినప్పుడు, సాధారణంగా వివిధ మధ్యంతర-కోడ్ కార్యకలాపాల సంఖ్య చాలా ఎక్కువగా ఉంటుంది.


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

మేము ప్రతి సింటాక్టిక్ వర్గానికి అనువాద ఫంక్షన్లను ఉపయోగించి కోడ్‌ను రూపొందిస్తాము.


ఈ రోజు సూర్యుడు ప్రకాశవంతంగా ప్రకాశిస్తున్నాడు.


దయచేసి నాకు ఉప్పు అందిస్తారా?


I am going to the market to buy some vegetables.

నేను కూరగాయలు కొనడానికి మార్కెట్‌కి వెళ్తున్నాను.


The company announced its quarterly profits.

కంపెనీ తన త్రైమాసిక లాభాలను ప్రకటించింది.


The new policy will affect all employees.

కొత్త విధానం ఉద్యోగులందరినీ ప్రభావితం చేస్తుంది.


The research team is working on a new project.

పరిశోధనా బృందం ఒక కొత్త ప్రాజెక్ట్‌పై పనిచేస్తోంది.


The algorithm efficiently sorts the data.

అల్గారిథం డేటాను సమర్ధవంతంగా క్రమబద్ధీకరిస్తుంది.


అతను చాలా ప్రతిభావంతుడైన సంగీత విద్వాంసుడు.


She enjoys reading novels in her free time.

ఆమె ఖాళీ సమయంలో నవలలు చదవడానికి ఇష్టపడుతుంది.


The government is implementing new regulations.

ప్రభుత్వం కొత్త నిబంధనలను అమలు చేస్తోంది.


The economic forecast predicts a slow recovery.

ఆర్థిక సూచన నెమ్మదిగా కోలుకుంటుందని అంచనా వేసింది.


The software requires frequent updates to fix bugs.

బగ్‌లను పరిష్కరించడానికి సాఫ్ట్‌వేర్‌కు తరచుగా నవీకరణలు అవసరం.


The complex system architecture was difficult to understand.

సంక్లిష్టమైన సిస్టమ్ ఆర్కిటెక్చర్ అర్థం చేసుకోవడం కష్టం.


Despite the challenges, they persevered and succeeded.

సవాళ్లు ఉన్నప్పటికీ, వారు పట్టుదలతో విజయం సాధించారు.


The implications of the decision are far-reaching.

ఈ నిర్ణయం యొక్క పరిణామాలు చాలా దూరం వరకు ఉంటాయి.


The company's innovative approach disrupted the market.

కంపెనీ యొక్క వినూత్న విధానం మార్కెట్‌ను దెబ్బతీసింది.


The study explores the correlation between climate change and rising sea levels.

వాతావరణ మార్పులు మరియు సముద్ర మట్టాలు పెరగడానికి మధ్య సంబంధాన్ని ఈ అధ్యయనం పరిశీలిస్తుంది.


The algorithm's efficiency is paramount for large datasets.

పెద్ద డేటాసెట్‌ల కోసం అల్గారిథం యొక్క సామర్థ్యం చాలా ముఖ్యం.


He was a polymath, excelling in various fields of study.

అతను బహుముఖ ప్రజ్ఞాశాలి, వివిధ అధ్యయన రంగాలలో రాణించాడు.


The philosophical treatise delved into the nature of existence.

తత్వశాస్త్ర గ్రంథం ఉనికి స్వభావాన్ని పరిశోధించింది.


The compiler ensures the symbol table contains necessary information for translation.

అనువాదం కోసం అవసరమైన సమాచారాన్ని సింబల్ టేబుల్ కలిగి ఉండేలా కంపైలర్ చూసుకుంటుంది.


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

ఒక వేరియబుల్ ప్రకటించినప్పుడు, కంపైలర్ దాని సమాచారాన్ని సింబల్ టేబుల్‌లో నిల్వ చేస్తుంది.


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

పూర్ణాంక వేరియబుల్స్ కోసం, సింబల్ టేబుల్ ఎంట్రీలో ఇంటర్మీడియట్-భాషా వేరియబుల్ ఉంటుంది.


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

అరే వేరియబుల్స్ కోసం బేస్ అడ్రస్ మరియు డైమెన్షన్స్ సింబల్ టేబుల్‌లో ఉండాలి.


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

రికార్డ్‌లకు ప్రతి ఫీల్డ్ కోసం ఆఫ్‌సెట్‌లు మరియు మొత్తం పరిమాణం సింబల్ టేబుల్‌లో అవసరం.


If a type is named, the symbol table describes the type.

ఒక రకానికి పేరు పెడితే, సింబల్ టేబుల్ ఆ రకాన్ని వివరిస్తుంది.


Translation functions often use these tables.

అనువాద విధులు తరచుగా ఈ పట్టికలను ఉపయోగిస్తాయి.


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

ముందుగా పేర్ల వినియోగానికి అనువాద విధులు రాయడం మంచిది.


Chapter 10 will cover function declaration translations.

అధ్యాయం 10 ఫంక్షన్ డిక్లరేషన్ అనువాదాలను కవర్ చేస్తుంది.


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

మేము పూర్ణాంక వేరియబుల్స్ మరియు ఒక-డైమెన్షనల్ పూర్ణాంక శ్రేణులను ప్రకటించవచ్చు.


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

ఒక పూర్ణాంక వేరియబుల్ సింబల్ టేబుల్‌లోని ఒక స్థానానికి బౌండ్ చేయబడాలి.


An array should be bound to a variable containing its base address.

ఒక శ్రేణి దాని బేస్ చిరునామాను కలిగి ఉన్న వేరియబుల్‌కు బౌండ్ చేయబడాలి.


Code must be generated for allocating space for the array.

శ్రేణి కోసం స్థలాన్ని కేటాయించడానికి కోడ్ ఉత్పత్తి చేయాలి.


శ్రేణులు హీప్ కేటాయించబడతాయని మేము భావిస్తున్నాము.


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.

JVM సంక్లిష్ట కార్యకలాపాల కోసం సింగిల్ సూచనలను కలిగి ఉంది.


By letting complex operations be done by single instructions, the code is smaller.

సంక్లిష్ట కార్యకలాపాలను సింగిల్ సూచనల ద్వారా చేయడానికి అనుమతించడం ద్వారా, కోడ్ చిన్నదిగా ఉంటుంది.


The algorithm's efficiency depends on the number of nodes and edges in the graph.

అల్గారిథం యొక్క సామర్థ్యం గ్రాఫ్‌లోని నోడ్‌లు మరియు అంచుల సంఖ్యపై ఆధారపడి ఉంటుంది.


Spilling variables to memory is a necessary step when register allocation fails.

రిజిస్టర్ కేటాయింపు విఫలమైనప్పుడు మెమరీకి వేరియబుల్స్‌ను స్పిల్ చేయడం ఒక అవసరమైన దశ.


The compiler uses heuristics to make informed decisions during register allocation.

రిజిస్టర్ కేటాయింపు సమయంలో సమాచారం ఆధారిత నిర్ణయాలు తీసుకోవడానికి కంపైలర్ హ్యూరిస్టిక్‌లను ఉపయోగిస్తుంది.


If a node has fewer than N edges, it can be placed on the stack.

ఒక నోడ్‌కు N కంటే తక్కువ అంచులు ఉంటే, దానిని స్టాక్‌లో ఉంచవచ్చు.


The select phase attempts to assign a color to each node.

ఎంచుకునే దశ ప్రతి నోడ్‌కు రంగును కేటాయించడానికి ప్రయత్నిస్తుంది.


Coalescing can improve register allocation by combining variables.

వేరియబుల్స్‌ను కలపడం ద్వారా కోలేసింగ్ రిజిస్టర్ కేటాయింపును మెరుగుపరుస్తుంది.


The activation record stores information about a function's execution.

యాక్టివేషన్ రికార్డ్ ఒక ఫంక్షన్ అమలు గురించి సమాచారాన్ని నిల్వ చేస్తుంది.


Function calls require a call sequence to manage the stack and parameters.

ఫంక్షన్ కాల్‌లకు స్టాక్ మరియు పారామితులను నిర్వహించడానికి కాల్ సీక్వెన్స్ అవసరం.


The prologue of a function prepares the environment for execution.

ఒక ఫంక్షన్ యొక్క ప్రారంభం అమలు కోసం వాతావరణాన్ని సిద్ధం చేస్తుంది.


The epilogue restores the state before returning from a function.

ఒక ఫంక్షన్ నుండి తిరిగి వచ్చే ముందు ఎపిలోగ్ స్థితిని పునరుద్ధరిస్తుంది.


Register allocation aims to assign variables to registers for faster access.

వేగవంతమైన యాక్సెస్ కోసం వేరియబుల్స్‌ను రిజిస్టర్‌లకు కేటాయించడం రిజిస్టర్ కేటాయింపు లక్ష్యం.


The interference graph helps visualize the relationships between variables.

వేరియబుల్స్ మధ్య సంబంధాలను దృశ్యమానం చేయడానికి ఇంటర్‌ఫెరెన్స్ గ్రాఫ్ సహాయపడుతుంది.


Spilling is the process of moving variables from registers to memory.

స్పిల్లింగ్ అనేది వేరియబుల్స్‌ను రిజిస్టర్‌ల నుండి మెమరీకి తరలించే ప్రక్రియ.


Heuristics are used to make informed choices during the allocation process.

కేటాయింపు ప్రక్రియలో సమాచారం ఆధారిత ఎంపికలు చేయడానికి హ్యూరిస్టిక్‌లను ఉపయోగిస్తారు.


The stack is used to store local variables and function parameters.

స్థానిక వేరియబుల్స్ మరియు ఫంక్షన్ పారామితులను నిల్వ చేయడానికి స్టాక్ ఉపయోగించబడుతుంది.


The compiler optimizes code to improve performance.

పనితీరును మెరుగుపరచడానికి కంపైలర్ కోడ్‌ను ఆప్టిమైజ్ చేస్తుంది.


Understanding register allocation is crucial for efficient code generation.

సమర్థవంతమైన కోడ్ ఉత్పత్తి కోసం రిజిస్టర్ కేటాయింపును అర్థం చేసుకోవడం చాలా ముఖ్యం.


The algorithm simplifies the graph by removing nodes with fewer edges.

తక్కువ అంచులు ఉన్న నోడ్‌లను తొలగించడం ద్వారా అల్గారిథం గ్రాఫ్‌ను సరళీకృతం చేస్తుంది.


The program's performance can be significantly affected by register allocation.

రిజిస్టర్ కేటాయింపు ద్వారా ప్రోగ్రామ్ యొక్క పనితీరు గణనీయంగా ప్రభావితం కావచ్చు.


The choice of which node to spill can impact the overall performance.

ఏ నోడ్‌ను స్పిల్ చేయాలనే ఎంపిక మొత్తం పనితీరును ప్రభావితం చేస్తుంది.


ఈ రోజు సూర్యుడు ప్రకాశవంతంగా ప్రకాశిస్తున్నాడు.


దయచేసి మీరు నాకు ఉప్పు ఇస్తారా?


I am going to the market to buy some vegetables.

నేను కూరగాయలు కొనడానికి మార్కెట్‌కి వెళ్తున్నాను.


The company announced its quarterly profits.

కంపెనీ తన త్రైమాసిక లాభాలను ప్రకటించింది.


డాక్టర్ అతనికి విశ్రాంతి తీసుకోవాలని సలహా ఇచ్చారు.


ఆమె చాలా ప్రతిభావంతులైన సంగీత విద్వాంసురాలు.


The government is implementing new policies.

ప్రభుత్వం కొత్త విధానాలను అమలు చేస్తోంది.


The research team conducted a thorough investigation.

పరిశోధనా బృందం సమగ్రమైన దర్యాప్తును నిర్వహించింది.


అతను అనేక భాషలలో అనర్గళంగా మాట్లాడగలడు.


The project requires careful planning and execution.

ఈ ప్రాజెక్ట్ జాగ్రత్తగా ప్రణాళిక మరియు అమలును కోరుతుంది.


The algorithm efficiently sorts the data.

అల్గారిథం డేటాను సమర్ధవంతంగా క్రమబద్ధీకరిస్తుంది.


సవాళ్లు ఉన్నప్పటికీ, వారు విజయం సాధించారు.


ఆర్థిక సూచన వృద్ధిని అంచనా వేస్తుంది.


The software update includes new features.

సాఫ్ట్‌వేర్ అప్‌డేట్‌లో కొత్త ఫీచర్‌లు ఉన్నాయి.


కమిటీ ప్రతిపాదనను సమీక్షిస్తుంది.


The complex system requires specialized knowledge.

సంక్లిష్టమైన వ్యవస్థకు ప్రత్యేక పరిజ్ఞానం అవసరం.


The implications of the decision are far-reaching.

ఈ నిర్ణయం యొక్క పరిణామాలు చాలా దూరం వరకు ఉంటాయి.


The company is undergoing restructuring.

కంపెనీ పునర్నిర్మాణం జరుగుతోంది.


The scientific community is debating the findings.

శాస్త్రీయ సమాజం ఈ ఫలితాలపై చర్చలు జరుపుతోంది.


The intricate details of the plan were revealed.

ప్రణాళిక యొక్క క్లిష్టమైన వివరాలు వెల్లడయ్యాయి.


ఫంక్షన్ కాల్ ఫలితాన్ని తిరిగి ఇస్తుంది.


Parameters and the return address are stored in the new frame.

కొత్త ఫ్రేమ్‌లో పారామీటర్లు మరియు రిటర్న్ చిరునామా నిల్వ చేయబడతాయి.


Keeping parameters in register-allocated variables can require a lot of registers.

పారామీటర్లను రిజిస్టర్-కేటాయించిన వేరియబుల్స్‌లో ఉంచడం చాలా రిజిస్టర్‌లను కోరుతుంది.


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

ప్రత్యామ్నాయం ఏమిటంటే, ప్రతి పరామితిని మూల్యాంకనం చేయగానే ఫ్రేమ్‌లో నిల్వ చేయడం.


This optimization must only be used if no parameter-expressions contain function calls.

పరామితి-ఎక్స్‌ప్రెషన్‌లలో ఫంక్షన్ కాల్‌లు లేకపోతే మాత్రమే ఈ ఆప్టిమైజేషన్ ఉపయోగించాలి.


In this simple call-sequence, we save on the stack all registers that can potentially hold variables.

ఈ సాధారణ కాల్-సీక్వెన్స్‌లో, వేరియబుల్స్‌ను కలిగి ఉండే అన్ని రిజిస్టర్‌లను మేము స్టాక్‌లో సేవ్ చేస్తాము.


Caller-saves need only save the registers that hold live variables.

కాలర్-సేవ్స్ లైవ్ వేరియబుల్స్‌ను కలిగి ఉన్న రిజిస్టర్‌లను మాత్రమే సేవ్ చేయాలి.


Callee-saves need only save the registers that the function actually uses.

కాలీ-సేవ్స్ ఫంక్షన్ వాస్తవానికి ఉపయోగించే రిజిస్టర్‌లను మాత్రమే సేవ్ చేయాలి.


When caller-saves is used, we might save a live variable in the frame even though the callee does not use the register.

కాలర్-సేవ్స్ ఉపయోగించినప్పుడు, కాలీ రిజిస్టర్‌ను ఉపయోగించనప్పటికీ, మేము ఫ్రేమ్‌లో లైవ్ వేరియబుల్‌ను సేవ్ చేయవచ్చు.


We can not avoid these unnecessary saves, as each function is compiled independently.

ప్రతి ఫంక్షన్ స్వతంత్రంగా కంపైల్ చేయబడినందున, ఈ అనవసరమైన సేవ్స్‌ను మేము నివారించలేము.


Calling conventions typically specify which registers are caller-saves and which are callee-saves.

కాలింగ్ కన్వెన్షన్‌లు సాధారణంగా ఏ రిజిస్టర్‌లు కాలర్-సేవ్స్ మరియు ఏవి కాలీ-సేవ్స్ అని పేర్కొంటాయి.


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

పారామీటర్లను మెమరీకి బదులుగా రిజిస్టర్‌లలో పంపితే ఇది చాలా మెమరీ ట్రాఫిక్‌ను ఆదా చేస్తుంది.


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

చాలా ఫంక్షన్లు చాలా చిన్న పరామితి జాబితాలను కలిగి ఉంటాయి, చాలా పరామితులు సాధారణంగా రిజిస్టర్‌లలో పంపబడతాయి.


The return address is also passed in a register.

రిటర్న్ చిరునామా కూడా రిజిస్టర్‌లో పంపబడుతుంది.


Most RISC architectures have jump-and-link (function-call) instructions.

చాలా RISC ఆర్కిటెక్చర్‌లు జంప్-అండ్-లింక్ (ఫంక్షన్-కాల్) సూచనలను కలిగి ఉంటాయి.


The register allocator can be used to optimise function calls.

ఫంక్షన్ కాల్‌లను ఆప్టిమైజ్ చేయడానికి రిజిస్టర్ కేటాయింపుదారుని ఉపయోగించవచ్చు.


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

ఫంక్షన్ కాల్ తర్వాత ఏ వేరియబుల్స్ లైవ్ లో ఉన్నాయో రిజిస్టర్ కేటాయింపుదారుడు చెప్పగలడు.


If a mixed strategy is used, variables that are live across a function call should, if possible, be allocated to callee-saves registers.

మిశ్రమ వ్యూహాన్ని ఉపయోగిస్తే, ఫంక్షన్ కాల్‌లో లైవ్ లో ఉన్న వేరియబుల్స్‌ను వీలైతే కాలీ-సేవ్స్ రిజిస్టర్‌లకు కేటాయించాలి.


Good programmers will use global variables sparingly.

మంచి ప్రోగ్రామర్లు గ్లోబల్ వేరియబుల్స్‌ను అరుదుగా ఉపయోగిస్తారు.


In C, there are no explicit call-by-reference parameters.

సి లో, స్పష్టమైన కాల్-బై-రిఫరెన్స్ పారామీటర్లు లేవు.


ఈ రోజు వాతావరణం ఆహ్లాదకరంగా ఉంది.


దయచేసి నాకు ఒక గ్లాసు నీరు తీసుకురండి.


నేను మార్కెట్‌కి వెళ్తున్నాను.


కంపెనీ ఒక కొత్త ఉత్పత్తిని ప్రకటించింది.


అతను చాలా ప్రతిభావంతుడైన సంగీత విద్వాంసుడు.


The government is implementing new policies.

ప్రభుత్వం కొత్త విధానాలను అమలు చేస్తోంది.


The algorithm efficiently sorts the data.

అల్గారిథం సమర్ధవంతంగా డేటాను క్రమబద్ధీకరిస్తుంది.


The research paper explores various methodologies.

పరిశోధనా పత్రం వివిధ పద్ధతులను అన్వేషిస్తుంది.


The economic forecast predicts a recession.

ఆర్థిక సూచన మాంద్యాన్ని అంచనా వేస్తుంది.


దయచేసి మీరు అది మళ్ళీ చెప్పగలరా?


నేను కొన్ని కిరాణా సామాగ్రి కొనాలి.


సమావేశం మధ్యాహ్నం 2 గంటలకు ప్రారంభమవుతుంది.


ప్రాజెక్ట్ జాగ్రత్తగా ప్రణాళికను కోరుతుంది.


The company's profits increased significantly.

కంపెనీ లాభాలు గణనీయంగా పెరిగాయి.


అతను సుప్రసిద్ధ రచయిత.


The software update includes new features.

సాఫ్ట్‌వేర్ అప్‌డేట్‌లో కొత్త ఫీచర్‌లు ఉన్నాయి.


The complex system requires extensive testing.

సంక్లిష్టమైన వ్యవస్థకు విస్తృత పరీక్షలు అవసరం.


The economic reforms have had a positive impact.

ఆర్థిక సంస్కరణలు సానుకూల ప్రభావాన్ని చూపాయి.


ఈ సమస్యతో మీరు నాకు సహాయం చేయగలరా?


నేను ఈ రోజు కొంచెం అలసిపోతున్నాను.


The compiler optimizes code to improve performance.

కంపైలర్ పనితీరును మెరుగుపరచడానికి కోడ్‌ను ఆప్టిమైజ్ చేస్తుంది.


Function calls can be optimized using techniques like inlining.

ఇన్‌లైనింగ్ వంటి పద్ధతులను ఉపయోగించి ఫంక్షన్ కాల్‌లను ఆప్టిమైజ్ చేయవచ్చు.


Tail call optimization avoids stack overflow errors.

టెయిల్ కాల్ ఆప్టిమైజేషన్ స్టాక్ ఓవర్‌ఫ్లో లోపాలను నివారిస్తుంది.


Memory management is crucial for program efficiency.

ప్రోగ్రామ్ సామర్థ్యం కోసం మెమరీ నిర్వహణ చాలా ముఖ్యం.


Static allocation assigns memory at compile time.

స్థిర కేటాయింపు కంపైల్ సమయంలో మెమరీని కేటాయిస్తుంది.


Stack allocation is fast but has limitations.

స్టాక్ కేటాయింపు వేగంగా ఉంటుంది, కానీ పరిమితులు ఉన్నాయి.


Heap allocation provides dynamic memory management.

హీప్ కేటాయింపు డైనమిక్ మెమరీ నిర్వహణను అందిస్తుంది.


Garbage collection automatically reclaims unused memory.

గార్బేజ్ కలెక్షన్ ఉపయోగించని మెమరీని స్వయంచాలకంగా తిరిగి పొందుతుంది.


The program uses a compiler to translate the code.

ప్రోగ్రామ్ కోడ్‌ను అనువదించడానికి కంపైలర్‌ను ఉపయోగిస్తుంది.


Variables are stored in memory during program execution.

ప్రోగ్రామ్ అమలు సమయంలో వేరియబుల్స్ మెమరీలో నిల్వ చేయబడతాయి.


The function calculates the sum of two numbers.

ఫంక్షన్ రెండు సంఖ్యల మొత్తాన్ని లెక్కిస్తుంది.


The system efficiently manages the available resources.

సిస్టమ్ అందుబాటులో ఉన్న వనరులను సమర్థవంతంగా నిర్వహిస్తుంది.


Dynamic memory allocation allows for flexible data structures.

డైనమిక్ మెమరీ కేటాయింపు సౌకర్యవంతమైన డేటా నిర్మాణాలను అనుమతిస్తుంది.


The algorithm optimizes the search process.

అల్గారిథం శోధన ప్రక్రియను ఆప్టిమైజ్ చేస్తుంది.


The software development process requires careful planning.

సాఫ్ట్‌వేర్ అభివృద్ధి ప్రక్రియకు జాగ్రత్తగా ప్రణాళిక అవసరం.


Understanding compiler optimization techniques is essential for writing efficient code.

సమర్థవంతమైన కోడ్ రాయడానికి కంపైలర్ ఆప్టిమైజేషన్ పద్ధతులను అర్థం చేసుకోవడం చాలా అవసరం.


The program's performance was significantly improved through code optimization.

కోడ్ ఆప్టిమైజేషన్ ద్వారా ప్రోగ్రామ్ పనితీరు గణనీయంగా మెరుగుపడింది.


Memory leaks can cause serious problems in long-running applications.

మెమరీ లీక్‌లు ఎక్కువసేపు నడుస్తున్న అప్లికేషన్‌లలో తీవ్రమైన సమస్యలను కలిగిస్తాయి.


The programmer used a debugger to find and fix the errors in the code.

ప్రోగ్రామర్ కోడ్‌లోని లోపాలను కనుగొని పరిష్కరించడానికి డీబగ్గర్‌ను ఉపయోగించాడు.


The efficiency of the algorithm is crucial for handling large datasets.

పెద్ద డేటాసెట్‌లను నిర్వహించడానికి అల్గారిథం యొక్క సామర్థ్యం చాలా ముఖ్యం.


The garbage collector moves data to free up memory.

చెత్తను సేకరించే వ్యక్తి మెమరీని ఖాళీ చేయడానికి డేటాను తరలిస్తాడు.


Generational collectors group objects by age.

తరాల కలెక్టర్లు వస్తువులను వయస్సు ప్రకారం సమూహపరుస్తారు.


The program needs to react quickly to outside changes.

ప్రోగ్రామ్ బయటి మార్పులకు త్వరగా స్పందించాలి.


Automatic memory management is essential for modern programming.

ఆధునిక ప్రోగ్రామింగ్‌కు ఆటోమేటిక్ మెమరీ నిర్వహణ చాలా అవసరం.


The compiler translates code from one language to another.

కంపైలర్ కోడ్‌ను ఒక భాష నుండి మరొక భాషలోకి అనువదిస్తుంది.


Bootstrapping is a technique used to build compilers.

బూట్‌స్ట్రాపింగ్ అనేది కంపైలర్‌లను నిర్మించడానికి ఉపయోగించే ఒక సాంకేతికత.


The machine directly executes language D.

మెషిన్ నేరుగా భాష Dని అమలు చేస్తుంది.


The interpreter translates code line by line.

ఇంటర్‌ప్రెటర్ కోడ్‌ను లైన్ బై లైన్‌గా అనువదిస్తుంది.


This process is similar to the chicken-and-egg paradox.

ఈ ప్రక్రియ కోడి-గుడ్డు విరుద్ధతను పోలి ఉంటుంది.


The compiler generates ARM machine code.

కంపైలర్ ARM మెషిన్ కోడ్‌ను ఉత్పత్తి చేస్తుంది.


We need a compiler for ML to x86 machine code.

ML నుండి x86 మెషిన్ కోడ్‌కు కంపైలర్ మనకు కావాలి.


The program is written in the language that the machine executes.

ప్రోగ్రామ్ మెషిన్ అమలు చేసే భాషలో వ్రాయబడింది.


The source program is shown at the left of the compiler.

సోర్స్ ప్రోగ్రామ్ కంపైలర్ ఎడమ వైపున చూపబడుతుంది.


The target program is shown on the right.

టార్గెట్ ప్రోగ్రామ్ కుడి వైపున చూపబడుతుంది.


The languages must match at every connection.

ప్రతి కనెక్షన్‌లో భాషలు సరిపోలాలి.


The compiler can now be used to compile itself.

కంపైలర్‌ను ఇప్పుడు అదే కంపైల్ చేయడానికి ఉపయోగించవచ్చు.


This can be useful if the compiler is later extended.

కంపైలర్‌ను తరువాత విస్తరించినట్లయితే ఇది ఉపయోగకరంగా ఉంటుంది.


Such combinations can be a bit confusing.

అటువంటి కలయికలు కొంచెం గందరగోళంగా ఉంటాయి.


We need a solid foundation in the form of a machine.

మెషిన్ రూపంలో మనకు ఒక దృఢమైన పునాది అవసరం.


When no existing compiler is available, we need a full bootstrap.

ఎటువంటి కంపైలర్ అందుబాటులో లేనప్పుడు, మనకు పూర్తి బూట్‌స్ట్రాప్ అవసరం.


వ్యాఖ్యలు ఒకదానిలో ఒకటి చేర్చబడ్డాయి.


Common subexpression elimination is a key optimization technique.

సాధారణ ఉప వ్యక్తీకరణ తొలగింపు ఒక ముఖ్యమైన ఆప్టిమైజేషన్ పద్ధతి.


కంపైలేషన్ అనేక దశలను కలిగి ఉంటుంది.


Compile-time errors are detected during the compilation process.

కంపైల్ సమయం లోపాలు కంపైలేషన్ ప్రక్రియలో గుర్తించబడతాయి.


కంపైలర్‌లను కంపైల్ చేయడం ఒక సంక్లిష్టమైన పని.


A conflict arises when the grammar is ambiguous.

వ్యాకరణం అస్పష్టంగా ఉన్నప్పుడు ఒక సంఘర్షణ ఏర్పడుతుంది.


Reduce-reduce conflicts and shift-reduce conflicts are common in parsing.

తగ్గించు-తగ్గించు సంఘర్షణలు మరియు షిఫ్ట్-తగ్గించు సంఘర్షణలు పార్సింగ్‌లో సాధారణం.


కోడ్ స్థిరంగా ఉండాలి.


స్థిరమైనవి ఆపరేండ్‌లలో ఉండవచ్చు.


Constant propagation is an optimization technique.

స్థిరమైన ప్రచారం ఒక ఆప్టిమైజేషన్ పద్ధతి.


Context-free grammars are fundamental to compiler design.

సందర్భ రహిత వ్యాకరణాలు కంపైలర్ రూపకల్పనకు మూలస్తంభాలు.


The dangling-else problem is a classic parsing issue.

డాంగ్లింగ్-ఎల్‌స్ సమస్య ఒక క్లాసిక్ పార్సింగ్ సమస్య.


Data-flow analysis is used for optimization.

డేటా-ఫ్లో విశ్లేషణ ఆప్టిమైజేషన్ కోసం ఉపయోగించబడుతుంది.


Dead code elimination improves efficiency.

డెడ్ కోడ్ తొలగింపు సామర్థ్యాన్ని మెరుగుపరుస్తుంది.


A dead variable is one whose value is never used.

డెడ్ వేరియబుల్ అంటే దాని విలువను ఎప్పుడూ ఉపయోగించనిది.


Declarations define the meaning of identifiers.

గుర్తింపుదారుల అర్థాన్ని ప్రకటనలు నిర్వచిస్తాయి.


Global and local declarations have different scopes.

గ్లోబల్ మరియు లోకల్ డిక్లరేషన్లు వేర్వేరు పరిధులను కలిగి ఉంటాయి.


Derivation is the process of applying grammar rules.

వ్యుత్పత్తి అనేది వ్యాకరణ నియమాలను వర్తింపజేసే ప్రక్రియ.


Leftmost and rightmost derivations are important concepts.

ఎడమ మరియు కుడి వైపున ఉన్న ఉత్పన్నాలు ముఖ్యమైన భావనలు.


DFA పద విశ్లేషణలో ఉపయోగించబడుతుంది.


The compiler translates code written in a high-level language into machine code.

కంపైలర్ ఒక ఉన్నత స్థాయి భాషలో వ్రాసిన కోడ్‌ను మెషిన్ కోడ్‌గా అనువదిస్తుంది.


Bootstrapping is a process where a compiler is used to compile itself.

బూట్‌స్ట్రాపింగ్ అనేది కంపైలర్‌ను అదే కంపైలర్‌ను కంపైల్ చేయడానికి ఉపయోగించే ప్రక్రియ.


The QAD compiler allows programs in the new language to be executed.

QAD కంపైలర్ కొత్త భాషలోని ప్రోగ్రామ్‌లను అమలు చేయడానికి అనుమతిస్తుంది.


We can write a QAD interpreter instead of a QAD compiler.

QAD కంపైలర్‌కు బదులుగా, మేము QAD ఇంటర్‌ప్రెటర్‌ను వ్రాయవచ్చు.


The need for this extra step might be a bit clearer if we had let the “real” compiler generate x86 code instead.

“నిజమైన” కంపైలర్ x86 కోడ్‌ను ఉత్పత్తి చేయడానికి అనుమతించినట్లయితే, ఈ అదనపు దశ యొక్క అవసరం కొంచెం స్పష్టంగా ఉండవచ్చు.


The result of this is a compiler with the desired functionality, but it will probably run slowly.

దీని ఫలితంగా కావలసిన కార్యాచరణతో కూడిన కంపైలర్ వస్తుంది, కానీ ఇది బహుశా నెమ్మదిగా నడుస్తుంది.


For some languages, a QAD compiler will be easier to write than an interpreter.

కొన్ని భాషలకు, ఒక QAD కంపైలర్‌ను ఇంటర్‌ప్రెటర్ కంటే సులభంగా వ్రాయవచ్చు.


It is also possible to build the new language and its compiler incrementally.

క్రమంగా కొత్త భాషను మరియు దాని కంపైలర్‌ను నిర్మించడం కూడా సాధ్యమే.


The first step is to write a compiler for a small subset of the language.

మొదటి దశ భాష యొక్క చిన్న ఉపసమితి కోసం కంపైలర్‌ను రాయడం.


The notation for interpreters, machines and unspecified programs was added later.

ఇంటర్‌ప్రెటర్లు, మెషీన్‌లు మరియు పేర్కొనబడని ప్రోగ్రామ్‌ల కోసం సంజ్ఞామానం తరువాత జోడించబడింది.


An early bootstrapped compiler was LISP 1.5.

ప్రారంభంలో బూట్‌స్ట్రాప్ చేయబడిన కంపైలర్ LISP 1.5.


The first Pascal compiler was made using incremental bootstrapping.

మొదటి పాస్కల్ కంపైలర్‌ను క్రమంగా బూట్‌స్ట్రాపింగ్ ఉపయోగించి తయారు చేశారు.


Bootstrapping might not be complete even if a compiler with the right functionality has been obtained.

సరైన కార్యాచరణతో కూడిన కంపైలర్‌ను పొందినప్పటికీ బూట్‌స్ట్రాపింగ్ పూర్తి కాకపోవచ్చు.


The advantage of this approach is that a single binary translator can port any number of programs, not just compilers.

ఈ విధానం యొక్క ప్రయోజనం ఏమిటంటే, ఒకే బైనరీ అనువాదకుడు కంపైలర్‌లను మాత్రమే కాకుండా, ఎన్ని ప్రోగ్రామ్‌లనైనా పోర్ట్ చేయగలడు.


You have a machine that can execute Alpha machine code.

మీరు ఆల్ఫా మెషిన్ కోడ్‌ను అమలు చేయగల ఒక యంత్రాన్ని కలిగి ఉన్నారు.


Show how a compiler from ML to C written in Alpha machine code can be generated from the above components.

పై భాగాల నుండి ఆల్ఫా మెషిన్ కోడ్‌లో వ్రాసిన ML నుండి Cకి కంపైలర్‌ను ఎలా రూపొందించవచ్చో చూపండి.


A source-code optimiser is a program that can optimise programs at source-code level.

సోర్స్-కోడ్ ఆప్టిమైజర్ అనేది సోర్స్-కోడ్ స్థాయిలో ప్రోగ్రామ్‌లను ఆప్టిమైజ్ చేయగల ఒక ప్రోగ్రామ్.


ఒక సెట్ అనేది అంశాల సమాహారం.


The order of elements do not matter in a set.

ఒక సెట్‌లో మూలకాల క్రమం ముఖ్యం కాదు.


We will typically use uppercase letters to denote sets and lowercase letters to denote elements in a set.

మేము సాధారణంగా సెట్‌లను సూచించడానికి పెద్ద అక్షరాలను మరియు సెట్‌లోని మూలకాలను సూచించడానికి చిన్న అక్షరాలను ఉపయోగిస్తాము.


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() మళ్ళీ స్థిరమైన సమయం, కానీ మేము లేకపోతే కంటే తక్కువ బ్లాక్‌లను విలీనం చేస్తాము.


For example, freeing the 12-byte block in figure 12.1(b) will not make it join with the second block in the free list, as this neighbours the freed block on the wrong side.

ఉదాహరణకు, 12-బైట్ బ్లాక్‌ను విడుదల చేయడం వలన అది ఉచిత జాబితాలోని రెండవ బ్లాక్‌తో కలవదు, ఎందుకంటే ఇది తప్పు వైపున విడుదల చేసిన బ్లాక్‌కు పొరుగున ఉంది.


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 the next free list is also empty, we go to the next again and so on.

తదుపరి ఉచిత జాబితా కూడా ఖాళీగా ఉంటే, మేము మళ్ళీ తదుపరిదికి వెళ్తాము మరియు ఇలాగే కొనసాగుతాము.


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.

విచ్ఛిన్నతను తగ్గించడానికి మరియు విడుదల చేసిన బ్లాక్‌లను వేగంగా కలపడానికి, కొంతమంది మెమరీ నిర్వాహకులు బ్లాక్‌లను బ్లాక్ పరిమాణానికి సమలేఖనం చేయడానికి పరిమితం చేస్తారు.


So a 16-word block would have an address that is 16-word aligned, a 32-word block would be 32-word aligned, and so on.

అందువల్ల 16-పదాల బ్లాక్ 16-పదాల సమలేఖనం చేయబడిన చిరునామాను కలిగి ఉంటుంది, 32-పదాల బ్లాక్ 32-పదాల సమలేఖనం చేయబడుతుంది మరియు ఇలాగే.


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.

బడ్డీ వాడుకలో లేకపోతే (సరి సంఖ్య పరిమాణ ఫీల్డ్‌ను కలిగి ఉండటం ద్వారా సూచించబడుతుంది) మరియు విడుదల చేసిన బ్లాక్ వలె అదే పరిమాణంలో ఉంటే, మేము రెండు బ్లాక్‌లను బడ్డీ యొక్క పరిమాణ ఫీల్డ్‌లో అతి తక్కువ చిరునామాతో పరిమాణాన్ని రెట్టింపు చేయడం ద్వారా విలీనం చేస్తాము.