ஒரு கம்பைலர் என்றால் என்ன?


ஒரு கம்பைலரின் கட்டங்கள் முக்கியம்.


Interpreters are also used in programming.

நிரலாக்கத்தில் மொழிபெயர்ப்பாளர்களும் பயன்படுத்தப்படுகிறார்கள்.


கம்பைலர்களைப் பற்றி ஏன் கற்றுக்கொள்ள வேண்டும்?


இந்தப் புத்தகம் விரிவுரையாளர்களுக்காக எழுதப்பட்டது.


Regular expressions are used for lexical analysis.

வழக்கமான வெளிப்பாடுகள் லெக்சிகல் பகுப்பாய்விற்குப் பயன்படுத்தப்படுகின்றன.


Nondeterministic finite automata are a key concept.

நிர்ணயமற்ற முடிவுறு ஆட்டோமேட்டா ஒரு முக்கிய கருத்தாகும்.


Converting a regular expression to an NFA is a process.

ஒரு வழக்கமான வெளிப்பாட்டை NFA ஆக மாற்றுவது ஒரு செயல்முறை.


Deterministic finite automata are efficient.

நிர்ணயிக்கப்பட்ட முடிவுறு ஆட்டோமேட்டா திறமையானவை.


Minimisation of DFAs is important for optimization.

DFA களின் குறைப்பு, மேம்படுத்தலுக்கு முக்கியமானது.


லெக்சர் ஜெனரேட்டர்கள் பயனுள்ள கருவிகள்.


சூழல்-இலவச இலக்கணங்கள் அடிப்படை.


சொற்றொடர் மரங்களும் தெளிவின்மையும் தொடர்புடையவை.


Operator precedence is a key concept in parsing.

செயற்குறி முன்னுரிமை என்பது பகுப்பாய்வில் ஒரு முக்கிய கருத்தாகும்.


முன்னறிவிப்பு பகுப்பாய்வு ஒரு நுட்பமாகும்.


LL(1) பகுப்பாய்வு என்பது ஒரு வகை பகுப்பாய்வு ஆகும்.


SLR பகுப்பாய்வு மற்றொரு பகுப்பாய்வு முறையாகும்.


Symbol tables are used to store information.

சின்ன அட்டவணைகள் தகவல்களைச் சேமிக்கப் பயன்படுகின்றன.


வகை சரிபார்ப்பு ஒரு முக்கியமான படியாகும்.


Intermediate-code generation is a phase.

இடைநிலை-குறியீடு உருவாக்கம் ஒரு கட்டமாகும்.


The compiler translates high-level language to machine language.

கம்ப்யூட்டர் உயர்-நிலை மொழியை இயந்திர மொழிக்கு மொழிபெயர்க்கிறது.


Lexical analysis divides the text into tokens.

சொல் பகுப்பாய்வு உரையை டோக்கன்களாகப் பிரிக்கிறது.


Syntax analysis arranges tokens into a tree structure.

சொற்றொடரியல் பகுப்பாய்வு டோக்கன்களை ஒரு மர அமைப்பாக ஒழுங்கமைக்கிறது.


Type checking ensures the program's consistency.

வகை சரிபார்ப்பு நிரலின் நிலைத்தன்மையை உறுதி செய்கிறது.


A compiler is essential for software development.

ஒரு கம்பைலர் மென்பொருள் உருவாக்கத்திற்கு அவசியம்.


The program was written in a high-level language.

நிரல் ஒரு உயர்-நிலை மொழியில் எழுதப்பட்டது.


The compiler identifies programmer mistakes.

கம்ப்யூட்டர் புரோகிராமர் தவறுகளை அடையாளம் காண்கிறது.


High-level languages are easier for humans to understand.

உயர்-நிலை மொழிகள் மனிதர்களுக்குப் புரிந்துகொள்ள எளிதானவை.


The same program can run on different machines.

ஒரே நிரலை வெவ்வேறு இயந்திரங்களில் இயக்க முடியும்.


Some programs are written in machine language for speed.

சில நிரல்கள் வேகத்திற்காக இயந்திர மொழியில் எழுதப்படுகின்றன.


A good compiler optimizes code for performance.

ஒரு நல்ல கம்பைலர் செயல்திறனுக்காக குறியீட்டை மேம்படுத்துகிறது.


The compilation process is divided into phases.

தொகுப்பு செயல்முறை கட்டங்களாக பிரிக்கப்பட்டுள்ளது.


Each phase has a well-defined interface.

ஒவ்வொரு கட்டமும் நன்கு வரையறுக்கப்பட்ட இடைமுகத்தைக் கொண்டுள்ளது.


Lexical analysis is the initial part of program analysis.

சொல் பகுப்பாய்வு நிரல் பகுப்பாய்வின் ஆரம்ப பகுதியாகும்.


Syntax analysis is also known as parsing.

சொற்றொடரியல் பகுப்பாய்வு பார்சிங் என்றும் அழைக்கப்படுகிறது.


Type checking ensures variable types are consistent.

வகை சரிபார்ப்பு மாறி வகைகள் நிலையானவை என்பதை உறுதி செய்கிறது.


The compiler translates source code into executable code.

கம்ப்யூட்டர் மூலக் குறியீட்டை இயக்கக்கூடிய குறியீடாக மொழிபெயர்க்கிறது.


Understanding compiler phases is crucial for optimization.

தொகுப்பான் கட்டங்களைப் புரிந்துகொள்வது மேம்படுத்துவதற்கு முக்கியமானது.


The compiler's role is to bridge the gap between human-readable code and machine instructions.

மனிதர்களால் படிக்கக்கூடிய குறியீடு மற்றும் இயந்திர வழிமுறைகளுக்கு இடையே உள்ள இடைவெளியை நிரப்புவதே கம்பைலரின் பணியாகும்.


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

தரவு ஓட்டப் பகுப்பாய்வு என்பது கம்பைலர் மேம்படுத்தலில் பயன்படுத்தப்படும் ஒரு முக்கிய நுட்பமாகும்.


இன்று சூரியன் பிரகாசமாக பிரகாசிக்கிறது.


உப்பு கொஞ்சம் கொடுக்க முடியுமா?


I am going to the market to buy some vegetables.

நான் காய்கறிகள் வாங்க சந்தைக்குப் போகிறேன்.


The company announced a new product launch next month.

நிறுவனம் அடுத்த மாதம் புதிய தயாரிப்பு வெளியீட்டை அறிவித்தது.


The algorithm efficiently sorts the data.

அல்காரிதம் தரவை திறமையாக வரிசைப்படுத்துகிறது.


அவர் மிகவும் திறமையான இசைக்கலைஞர்.


The weather forecast predicts rain for tomorrow.

நாளை மழை பெய்யும் என்று வானிலை முன்னறிவிப்பு கூறுகிறது.


Please submit your application before the deadline.

சமர்ப்பிப்பதற்கான காலக்கெடுவிற்குள் உங்கள் விண்ணப்பத்தை சமர்ப்பிக்கவும்.


The research paper explores the impact of climate change.

ஆராய்ச்சி கட்டுரை காலநிலை மாற்றத்தின் தாக்கத்தை ஆராய்கிறது.


She enjoys reading novels in her free time.

அவள் தனது ஓய்வு நேரத்தில் நாவல்கள் படிப்பதை விரும்புகிறாள்.


The government implemented new policies to boost the economy.

பொருளாதாரத்தை மேம்படுத்த அரசு புதிய கொள்கைகளை அமல்படுத்தியது.


The software update includes several bug fixes.

மென்பொருள் புதுப்பிப்பில் பல பிழை திருத்தங்கள் உள்ளன.


அவர் பல மொழிகளில் சரளமாக பேசுகிறார்.


அடுத்த வாரம் மாநாடு நடைபெறும்.


The data analysis revealed interesting patterns.

தரவு பகுப்பாய்வு சுவாரஸ்யமான வடிவங்களை வெளிப்படுத்தியது.


She is a dedicated teacher who inspires her students.

அவள் தனது மாணவர்களுக்கு உத்வேகம் அளிக்கும் ஒரு அர்ப்பணிப்புள்ள ஆசிரியை.


The project requires careful planning and execution.

இந்த திட்டத்திற்கு கவனமாக திட்டமிடல் மற்றும் செயல்படுத்துதல் தேவை.


The company's profits increased significantly this quarter.

நிறுவனத்தின் லாபம் இந்த காலாண்டில் கணிசமாக அதிகரித்துள்ளது.


The complex system requires specialized knowledge to operate.

சிக்கலான இந்த அமைப்பை இயக்க, சிறப்பு அறிவு தேவை.


The artist's work is known for its unique style and creativity.

அந்த கலைஞரின் படைப்புகள் தனித்துவமான பாணி மற்றும் படைப்பாற்றலுக்காக அறியப்படுகின்றன.


The compiler translates the program into machine code.

கம்ப்யூட்டர் நிரல் மொழிபெயர்ப்பாளர் நிரலை இயந்திரக் குறியீடாக மொழிபெயர்க்கிறார்.


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 in a programming language.

நிரலாக்க மொழியில் டோக்கன்களை வரையறுக்க வழக்கமான வெளிப்பாடுகள் பயன்படுத்தப்படுகின்றன.


The syntax tree represents the structure of the program.

தொடரியல் மரம் நிரலின் கட்டமைப்பை பிரதிபலிக்கிறது.


Assembly language is a low-level programming language.

அசெம்பிளி மொழி ஒரு குறைந்த-நிலை நிரலாக்க மொழியாகும்.


The backend of a compiler generates machine code.

ஒரு கம்பைலரின் பின் பகுதி இயந்திரக் குறியீட்டை உருவாக்குகிறது.


Type checking ensures that the program is type-safe.

வகை சரிபார்ப்பு நிரல் வகை பாதுகாப்பானது என்பதை உறுதி செய்கிறது.


Optimization improves the performance of the compiled code.

உகப்பாக்கம் தொகுக்கப்பட்ட குறியீட்டின் செயல்திறனை மேம்படுத்துகிறது.


A domain-specific language is designed for a specific task.

ஒரு கள-குறிப்பிட்ட மொழி ஒரு குறிப்பிட்ட பணிக்கு வடிவமைக்கப்பட்டுள்ளது.


The book discusses compiler construction techniques.

புத்தகம் கம்பைலர் உருவாக்கும் நுட்பங்களைப் பற்றி விவாதிக்கிறது.


The author explains the different phases of compilation.

ஆசிரியர் தொகுப்பின் வெவ்வேறு கட்டங்களை விளக்குகிறார்.


Understanding compilers helps programmers write better code.

கம்பைலர்களைப் புரிந்துகொள்வது புரோகிராமர்கள் சிறந்த குறியீட்டை எழுத உதவுகிறது.


The course covers the fundamentals of compiler design.

இந்த பாடநெறி கம்பைலர் வடிவமைப்பின் அடிப்படைகளை உள்ளடக்கியது.


The program encountered a syntax error during parsing.

பகுப்பாய்வின் போது நிரல் ஒரு தொடரியல் பிழையை சந்தித்தது.


The intermediate language simplifies code generation.

இடைநிலை மொழி குறியீடு உருவாக்கத்தை எளிதாக்குகிறது.


Register allocation is crucial for efficient code execution.

திறமையான குறியீடு செயல்படுத்தலுக்குப் பதிவு ஒதுக்கீடு முக்கியமானது.


The compiler's frontend handles lexical analysis and parsing.

கம்பைலரின் முன்பகுதி சொல் பகுப்பாய்வு மற்றும் பகுப்பாய்வைக் கையாளுகிறது.


The book provides examples of different compiler phases.

புத்தகம் வெவ்வேறு கம்பைலர் கட்டங்களின் எடுத்துக்காட்டுகளை வழங்குகிறது.


The goal is to create an optimized and efficient compiler.

உகந்த மற்றும் திறமையான கம்பைலரை உருவாக்குவதே இதன் நோக்கம்.


The DFA constructed from the NFA is shown in figure 2.5.

NFA இலிருந்து உருவாக்கப்பட்ட DFA படம் 2.5 இல் காட்டப்பட்டுள்ளது.


We now pick an unmarked element from the uncompleted S'.

இப்போது குறிக்கப்படாத ஒரு உறுப்பை முடிக்கப்படாத S' இலிருந்து தேர்ந்தெடுக்கிறோம்.


We now mark this and calculate the transitions for it.

இப்போது இதை குறித்து, அதற்கான மாற்றங்களை கணக்கிடுகிறோம்.


Note that the empty set of NFA states is not an DFA state.

NFA நிலைகளின் வெற்று தொகுப்பு DFA நிலை அல்ல என்பதை நினைவில் கொள்க.


We now adds'1 and s'2 to our incomplete S', which now is {√ s'0, s'1, s'2}.

இப்போது s'1 மற்றும் s'2 ஐ நமது முழுமையற்ற S' உடன் சேர்க்கிறோம், இது இப்போது {√ s'0, s'1, s'2} ஆகும்.


We have seen s'1 and s'2 before, so only s'3 is added.

நாம் ஏற்கனவே s'1 மற்றும் s'2 ஐ பார்த்திருக்கிறோம், எனவே s'3 மட்டுமே சேர்க்கப்பட்டது.


Which now completes the construction of S' = {s'0, s'1, s'2, s'3}.

இது இப்போது S' = {s'0, s'1, s'2, s'3} இன் கட்டமைப்பை நிறைவு செய்கிறது.


Only s'3 contains the accepting NFA state 4, so this is the only accepting state of our DFA.

s'3 இல் மட்டுமே ஏற்றுக்கொள்ளும் NFA நிலை 4 உள்ளது, எனவே இதுவே நமது DFA இன் ஒரே ஏற்றுக்கொள்ளும் நிலையாகும்.


படம் 2.9 முழுமையான DFA ஐக் காட்டுகிறது.


In the above example, we get a DFA with 4 states from an NFA with 8 states.

மேலே உள்ள எடுத்துக்காட்டில், 8 நிலைகளைக் கொண்ட NFA இலிருந்து 4 நிலைகளைக் கொண்ட ஒரு DFA ஐப் பெறுகிறோம்.


It is not too difficult to construct classes of NFAs that expand exponentially in this way when converted to DFAs.

DFAs ஆக மாற்றப்படும்போது, இந்த வழியில் அதிவேகமாக விரிவடையும் NFA களின் வகுப்புகளை உருவாக்குவது மிகவும் கடினம் அல்ல.


Since we are mainly interested in NFAs that are constructed from regular expressions as in section 2.4, we might ask ourselves if these might not be in a suitably simple class that do not risk exponential-sized DFAs.

நாம் முக்கியமாக பிரிவு 2.4 இல் உள்ளதைப் போல, வழக்கமான வெளிப்பாடுகளிலிருந்து கட்டமைக்கப்பட்ட NFAs இல் ஆர்வமாக இருப்பதால், இவை அதிவேக அளவிலான DFAs க்கு ஆபத்தை விளைவிக்காத வகையில் பொருத்தமான எளிய வகுப்பில் இல்லையா என்று நம்மை நாமே கேட்டுக்கொள்ளலாம்.


A DFA can be run in time k*|v|, where |v| is the length of the input string v and k is a small constant that is independent of the size of the DFA 1.

ஒரு DFA ஐ k*|v| நேரத்தில் இயக்க முடியும், இங்கு |v| என்பது உள்ளீட்டு சரத்தின் நீளம் மற்றும் k என்பது DFA இன் அளவைப் பொறுத்து இல்லாத ஒரு சிறிய மாறிலி 1.


All in all, DFAs are a lot faster to use than NFAs or regular expressions, so it is only when the size of the DFA is a real problem that one should consider using NFAs or regular expressions directly.

மொத்தத்தில், DFAs, NFAs அல்லது வழக்கமான வெளிப்பாடுகளை விடப் பயன்படுத்த மிகவும் வேகமானது, எனவே DFA இன் அளவு ஒரு உண்மையான பிரச்சனையாக இருக்கும்போது மட்டுமே ஒருவர் NFAs அல்லது வழக்கமான வெளிப்பாடுகளை நேரடியாகப் பயன்படுத்துவதைக் கருத்தில் கொள்ள வேண்டும்.


Even though the DFA in figure 2.9 has only four states, it is not minimal.

படம் 2.9 இல் உள்ள DFA இல் நான்கு நிலைகள் மட்டுமே இருந்தாலும், அது குறைந்தபட்சமாக இல்லை.


We can hence collapse these states into a single state and get a three-state DFA.

எனவே, இந்த நிலைகளை ஒரு தனி நிலைக்குச் சுருக்கி, மூன்று-நிலை DFA ஐப் பெறலாம்.


An interesting property of DFAs is that any regular language (a language that can be expressed by a regular expression, NFA or DFA) has a unique minimal DFA.

DFAs இன் சுவாரஸ்யமான அம்சம் என்னவென்றால், எந்தவொரு வழக்கமான மொழியும் (ஒரு வழக்கமான வெளிப்பாடு, NFA அல்லது DFA மூலம் வெளிப்படுத்தக்கூடிய மொழி) ஒரு தனித்துவமான குறைந்தபட்ச DFA ஐக் கொண்டுள்ளது.


Hence, we can decide equivalence of regular expressions (or NFAs or DFAs) by converting both to minimal DFAs and compare the results.

எனவே, இரண்டையும் குறைந்தபட்ச DFAs ஆக மாற்றுவதன் மூலம் வழக்கமான வெளிப்பாடுகள் (அல்லது NFAs அல்லது DFAs) சமநிலையைத் தீர்மானிக்க முடியும் மற்றும் முடிவுகளை ஒப்பிடலாம்.


இதற்காக பின்வரும் விதிகளைப் பயன்படுத்துகிறோம்:


If two states s1 and s2 have transitions on the same symbol c to states t1 and t2 that we have already proven to be different, then s1 and s2 are different.

இரண்டு நிலைகள் s1 மற்றும் s2 ஒரே சின்னம் c இல் t1 மற்றும் t2 நிலைகளுக்கு மாற்றங்களைக் கொண்டிருந்தால், அவை ஏற்கனவே வேறுபட்டவை என நிரூபிக்கப்பட்டிருந்தால், s1 மற்றும் s2 வேறுபட்டவை.


The program uses functions to choose productions.

நிரல் உற்பத்திகளைத் தேர்ந்தெடுக்க செயல்பாடுகளைப் பயன்படுத்துகிறது.


Each function examines the next input symbol.

ஒவ்வொரு செயல்பாடும் அடுத்த உள்ளீட்டு குறியீட்டை ஆராய்கிறது.


A terminal is matched against the next input symbol.

ஒரு முனையம் அடுத்த உள்ளீட்டு குறியீட்டுடன் பொருந்துகிறது.


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

அவை பொருந்தினால், நாம் பின்வரும் உள்ளீட்டு குறியீட்டிற்கு நகர்கிறோம்.


இல்லையெனில், ஒரு பிழை அறிவிக்கப்படுகிறது.


A nonterminal is handled by calling the corresponding function.

ஒரு முனையல்லாதது தொடர்புடைய செயல்பாட்டை அழைப்பதன் மூலம் கையாளப்படுகிறது.


The function returns when there are no more symbols.

மேலும் குறியீடுகள் இல்லாதபோது செயல்பாடு திரும்பும்.


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 can report an error if it is not in FIRST(T').

அது FIRST(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 a symbol as an argument.

match செயல்பாடு ஒரு குறியீட்டை ஒரு வாதமாக எடுத்துக்கொள்கிறது.


It tests for equality with the next input symbol.

இது அடுத்த உள்ளீட்டு குறியீட்டுடன் சமநிலையை சோதிக்கிறது.


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

படம் 3.16 இல் உள்ள நிரல் உள்ளீடு சரியானதா என்பதை மட்டுமே சரிபார்க்கிறது.


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.

ஒரு எளிய மறுநிகழ்வற்ற நிரல் இந்த அட்டவணையையும் ஒரு அடுக்கையும் பயன்படுத்துகிறது.


The table is cross-indexed by nonterminal and terminal.

அட்டவணை முனையல்லாத மற்றும் முனையத்தால் குறுக்கு-குறியிடப்பட்டுள்ளது.


This decision is made just as for recursive descent parsing.

இந்த முடிவு மறுநிகழ்வு இறங்கு பகுப்பாய்வைப் போலவே செய்யப்படுகிறது.


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.

அ) மேலே உள்ள விதிகளில் “...” இன் நிகழ்வுகளை ε மற்றும் s|t விதிகளில் காட்டப்பட்டுள்ளதைப் போன்ற வெளிப்பாடுகளால் மாற்றுவதன் மூலம் காலியாக இல்லாத வரையறையை முடிக்கவும்.


b) Use this definition to find non empty(a * 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

முன்னொட்டுகள்(a) = a? இங்கு a என்பது ஒரு எழுத்துரு சின்னம்


முன்னொட்டுகள்(s|t) = முன்னொட்டுகள்(s)|முன்னொட்டுகள்(t)


முன்னொட்டுகள்(s t) = ...


முன்னொட்டுகள்(s * ) = ...


முன்னொட்டுகள்(s + ) = ...


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 மற்றும் s|t விதிகளில் காட்டப்பட்டுள்ளதைப் போன்ற வெளிப்பாடுகளால் மாற்றுவதன் மூலம் முன்னொட்டுகளின் வரையறையை முடிக்கவும்.


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

ஆ) இந்த வரையறையைப் பயன்படுத்தி, முன்னொட்டுகள்(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.

எனவே, தொடரியல் மரத்தில் முக்கியமானது என்னவென்றால், இந்த இலைகள் மரத்தின் கட்டமைப்பை உருவாக்க எவ்வாறு இணைக்கப்படுகின்றன, மேலும் மரத்தின் உட்புற முனைகள் எவ்வாறு குறிக்கப்படுகின்றன.


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.

இருப்பினும், மீதமுள்ள உள்ளீட்டில் மற்ற பிழைகளைக் கண்டறிய கம்பைலர் முயற்சி செய்யலாம், மீண்டும் பயனர் ஒரு திருத்து-தொகுப்பு சுழற்சியில் பல பிழைகளைக் கண்டறிய அனுமதிக்கிறது.


Again, some of the subsequent errors may really be spurious errors caused by lexical error(s), so the user will have to guess at the validity of every error message except the first.

மீண்டும், சில பிந்தைய பிழைகள் உண்மையில் லெக்சிகல் பிழைகளால் ஏற்படும் தவறான பிழைகளாக இருக்கலாம், எனவே பயனர் முதல் பிழையைத் தவிர ஒவ்வொரு பிழை செய்தியின் செல்லுபடியாகும் தன்மையை யூகிக்க வேண்டும்.


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.

இருப்பினும், உள்ளீடு மிகவும் பெரியதாக இருக்கும்போது, உள்ளீட்டின் தொடக்கத்திலிருந்து லெக்சரை மறுதொடக்கம் செய்வது கணிசமான நேரத்தை எடுக்கும்போது, அத்தகைய பிழை மீட்பு உற்பத்தித்திறனுக்கு உதவியாக நிரூபிக்கப்பட்டுள்ளது.


Less commonly, the lexer may work interactively with a text editor and restart from the point at which an error was spotted after the user has tried to fix the error.

குறைவாக, லெக்சர் ஒரு உரை எடிட்டருடன் தொடர்பு கொண்டு செயல்படலாம் மற்றும் பயனர் பிழையை சரிசெய்ய முயற்சி செய்த பிறகு பிழை கண்டறியப்பட்ட புள்ளியிலிருந்து மறுதொடக்கம் செய்யலாம்.


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.

சாதாரணமாக, லெக்சர் ஜெனரேட்டர் வெற்று இடம் மற்றும் கருத்துகளை வழக்கமான வெளிப்பாடுகளால் வரையறுக்க வேண்டும்.


The actions for these regular expressions are typically empty, meaning that white-space and comments are just ignored.

இந்த வழக்கமான வெளிப்பாடுகளுக்கான செயல்கள் பொதுவாக காலியாக இருக்கும், அதாவது வெற்று இடம் மற்றும் கருத்துகள் புறக்கணிக்கப்படுகின்றன.


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.

அத்தகைய சந்தர்ப்பங்களில், முக்கிய வார்த்தைகள் லெக்சர் வரையறையில் தனித்தனி வழக்கமான வெளிப்பாடுகளாக விவரிக்கப்படவில்லை, மாறாக அடையாளங்காட்டி டோக்கனின் சிறப்பு நிகழ்வுகளாகக் கருதப்படுகின்றன.


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.

படம் 3.12 இந்த இலக்கணத்தைப் பயன்படுத்தி 2+3*4க்கான தொடரியல் மரத்தைக் காட்டுகிறது.


பரிந்துரைக்கப்பட்ட பயிற்சிகள்: 3.6.


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.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.

பிரச்சனை என்னவென்றால், எப்படிப் பயன்படுத்துவது என்பது தெளிவாகத் தெரியவில்லை. எடுத்துக்காட்டாக, p என்றால் q என்றால் s1 இல்லையெனில் 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.

நாம் என்றால், பின்னர் மற்றும் இல்லையெனில் ஒரு வகையான வலது-சம்பந்தப்பட்ட ஆபரேட்டர்களாகக் கருதலாம், ஏனெனில் இது அவற்றை வலதுபுறமாக குழுவாக்கும், ஒரு என்றால்-அப்போது மிக நெருக்கமானதை பொருத்துகிறது.


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.

மாறாக, பின்வரும் அவதானிப்பைப் பயன்படுத்துகிறோம்: ஒரு என்றால் மற்றும் ஒரு இல்லையெனில் பொருந்தியவுடன், இவை இரண்டிற்கும் இடையில் நிகழும் அனைத்து என்றால்-களும் பொருந்தும் இல்லையெனில்-களைக் கொண்டிருக்க வேண்டும்.


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.

இந்த இலக்கணம் அரைப்புள்ளி (வலது) மற்றும் அரைப்புள்ளியை விட என்றால் முன்னுரிமையையும் தீர்க்கிறது.


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.

தெளிவின்மையின் அனைத்து நிகழ்வுகளும் கவனமாக நடத்தப்பட வேண்டும்: தெளிவின்மையை நீக்குவது மட்டும் போதாது, விரும்பிய கட்டமைப்பில் விளைவிக்கும் வகையில் நாம் அவ்வாறு செய்ய வேண்டும்: எண்கணித வெளிப்பாடுகளின் கட்டமைப்பு முக்கியமானது, மேலும் எந்த என்றால்-க்கு இல்லையெனில் பொருந்துகிறது என்பதில் இது வேறுபடுகிறது.


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 asshiftactions and tran- sitions on nonterminals asgoactions.

விளைந்த DFA ஐ வரைகலை முறையில் காட்டுவதற்குப் பதிலாக, முனையங்களில் உள்ள மாற்றங்கள் ஷிஃப்ட் செயல்களாகவும், முனையமற்றவை கோஆக்சன்களாகவும் காட்டப்படும் ஒரு அட்டவணையை உருவாக்குகிறோம்.


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.26 இல் 3.27 இல் எப்சிலான்-மாற்றங்களைச் சேர்ப்பதன் மூலம் உருவாக்கப்பட்ட 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.

reduce மற்றும் accept செயல்களைச் சேர்ப்பதற்கு இவை கீழே தேவைப்படும், ஆனால் இது முடிந்ததும், அவை இனி தேவையில்லை, எனவே அவற்றை இறுதி அட்டவணையில் இருந்து அகற்றலாம்.


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

reduce மற்றும் accept செயல்களைச் சேர்க்க, முதலில் பிரிவு 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 ஐக் கணக்கிடுவதற்காக, பிரிவு 3.10 இல் விவரிக்கப்பட்டுள்ளபடி, உரை-இறுதி நிலைகளைக் கையாள, மற்றொரு கூடுதல் தொடக்க உற்பத்தியைச் சேர்க்கிறோம்: T ′′ → T ′ $.


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).

பின்னர், பின்வரும் விதியின் மூலம் reduce செயல்களைச் சேர்க்கிறோம்: ஒரு DFA நிலையில் ஒரு உற்பத்தி p:N→α க்கான ஏற்றுக்கொள்ளும் NFA நிலை இருந்தால், நாம் reduce pas செயலை 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 படம் 3.28: இலக்கணம் 3.9 இல் உள்ள அனைத்து சின்னங்களிலும் SLR DFA ஐப் பின்தொடர்கிறது(N).


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 NFA நிலை I ஐக் கொண்டுள்ளது, இது உற்பத்தி 3 ஐ ஏற்றுக்கொள்கிறது.


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

எனவே, நாம் r3 ஐ சின்னங்கள் c மற்றும் $ இல் செயல்களாகச் சேர்க்கிறோம் (ஏனெனில் இவை 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 asaccept(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 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 interpreter will typically consist of one function per syntactic category.

ஒரு மொழிபெயர்ப்பாளர் பொதுவாக ஒவ்வொரு தொடரியல் வகைக்கு ஒரு செயல்பாட்டைக் கொண்டிருக்கும்.


Each function will take as arguments an abstract syntax tree.

ஒவ்வொரு செயல்பாடும் வாதங்களாக ஒரு சுருக்கமான தொடரியல் மரத்தை எடுக்கும்.


Each function will return one or more results.

ஒவ்வொரு செயல்பாடும் ஒன்று அல்லது அதற்கு மேற்பட்ட முடிவுகளை வழங்கும்.


The functions can be implemented in any language.

செயல்பாடுகளை எந்த மொழியிலும் செயல்படுத்தலாம்.


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

விளக்கத்தின் கொள்கைகளை நிரூபிக்க ஒரு சிறிய மொழியைப் பயன்படுத்துவோம்.


தொடரியல் இலக்கணம் 5.1 இல் கொடுக்கப்பட்டுள்ளது.


The functions are all mutually recursive.

செயல்பாடுகள் அனைத்தும் ஒருவருக்கொருவர் மீண்டும் மீண்டும் நிகழ்கின்றன.


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.

இந்த செயல்பாட்டு அழைப்பின் முடிவு நிரலின் வெளியீடு ஆகும்.


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 grammars were first proposed as a notation for describing natural languages.

சூழல்-இலவச இலக்கணங்கள் முதலில் இயற்கை மொழிகளை விவரிக்க ஒரு குறியீடாக முன்மொழியப்பட்டன.


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

“சூழல்-இலவச” என்ற தகுதி இந்த குறியீட்டை மற்ற இரண்டு இலக்கணக் குறியீடுகளிலிருந்து வேறுபடுத்துகிறது.


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) பார்சிங்கைப் பயன்படுத்துகின்றன.


Several textbooks describe properties of context-free languages.

பல பாடப்புத்தகங்கள் சூழல்-இலவச மொழிகளின் பண்புகளை விவரிக்கின்றன.


The methods presented here for rewriting grammars based on operator precedence uses only infix operators.

ஆபரேட்டர் முன்னுரிமையின் அடிப்படையில் இலக்கணங்களை மீண்டும் எழுதுவதற்கான இங்கே வழங்கப்பட்ட முறைகள், இடைச்செருகல் ஆபரேட்டர்களை மட்டுமே பயன்படுத்துகின்றன.


If prefix or postfix operators have higher precedence than all infix operators, the method presented here will work.

முன்னொட்டு அல்லது பின்னொட்டு ஆபரேட்டர்கள் அனைத்து இடைச்செருகல் ஆபரேட்டர்களை விட அதிக முன்னுரிமை பெற்றிருந்தால், இங்கே வழங்கப்பட்ட முறை வேலை செய்யும்.


A method for handling arbitrary precedences of infix, prefix and postfix operators is presented in [1].

இடைச்செருகல், முன்னொட்டு மற்றும் பின்னொட்டு ஆபரேட்டர்களின் தன்னிச்சையான முன்னுரிமைகளை கையாளுவதற்கான ஒரு முறை [1]-ல் வழங்கப்பட்டுள்ளது.


Draw a third, different syntax tree for aabbbcc using the same grammar and show the left-derivation that corresponds to this syntax tree.

அதே இலக்கணத்தைப் பயன்படுத்தி aabbbcc க்கான மூன்றாவது, வேறுபட்ட தொடரியல் மரத்தை வரைந்து, இந்த தொடரியல் மரத்திற்கு ஒத்த இடது-வழித்தோன்றலைக் காட்டுங்கள்.


Write an unambiguous grammar for the language of balanced parentheses.

சமநிலை அடைப்புக்குறிகளின் மொழிக்கு ஒரு தெளிவற்ற இலக்கணத்தை எழுதுங்கள்.


Write grammars for each of the following languages:

பின்வரும் ஒவ்வொரு மொழிகளுக்கும் இலக்கணங்களை எழுதுங்கள்:


We extend the language of balanced parentheses from exercise 3.3 with two symbols: [ and ].

பயிற்சி 3.3 இலிருந்து சமநிலை அடைப்புக்குறிகளின் மொழியை இரண்டு சின்னங்களுடன் விரிவுபடுத்துகிறோம்: [ மற்றும் ].


Show that the grammar is ambiguous by finding a string that has two different syntax trees.

இரண்டு வெவ்வேறு தொடரியல் மரங்களைக் கொண்ட ஒரு சரத்தைக் கண்டுபிடிப்பதன் மூலம் இலக்கணம் தெளிவற்றது என்பதைக் காட்டுங்கள்.


Now make two different unambiguous grammars for the same language:

இப்போது அதே மொழிக்கு இரண்டு வெவ்வேறு தெளிவற்ற இலக்கணங்களை உருவாக்குங்கள்:


In some languages (like Pascal) a variable and a function in the same scope may have the same name.

சில மொழிகளில் (பாஸ்கல் போன்றவை) ஒரே பகுதியில் உள்ள ஒரு மாறி மற்றும் ஒரு செயல்பாடு ஒரே பெயரைப் பெறலாம்.


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

ஒரு பெயரை ஒரு தகவல் துண்டுடன் இணைக்க எங்களுக்குத் தேவை.


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

ஒரு கம்பைலர் பெயர்களையும், அவை இணைக்கப்பட்டுள்ள பொருள்களையும் கண்காணிக்க வேண்டும்.


The compiler translates high-level code into machine code.

மொழிபெயர்ப்பாளர் உயர்-நிலை குறியீட்டை இயந்திரக் குறியீடாக மொழிபெயர்க்கிறார்.


Type checking ensures that the program's data types are used correctly.

வகை சரிபார்ப்பு நிரலின் தரவு வகைகள் சரியாகப் பயன்படுத்தப்படுவதை உறுதி செய்கிறது.


The function takes two integer arguments and returns an integer.

செயல்பாடு இரண்டு முழு எண் வாதங்களை எடுத்துக்கொள்கிறது மற்றும் ஒரு முழு எண்ணை வழங்குகிறது.


The symbol table stores information about variables and functions.

சின்ன அட்டவணை மாறிகள் மற்றும் செயல்பாடுகள் பற்றிய தகவல்களைச் சேமிக்கிறது.


Error reporting is an important part of the compilation process.

பிழை அறிக்கை தொகுப்பு செயல்முறையின் ஒரு முக்கிய பகுதியாகும்.


The abstract syntax tree represents the structure of the program.

சுருக்கமான தொடரியல் மரம் நிரலின் கட்டமைப்பை பிரதிபலிக்கிறது.


Intermediate code is used as a stepping stone in the compilation.

இடைநிலை குறியீடு தொகுப்பில் ஒரு படியாகப் பயன்படுத்தப்படுகிறது.


The compiler performs several passes over the abstract syntax tree.

மொழிபெயர்ப்பாளர் சுருக்கமான தொடரியல் மரத்தின் மீது பல படிகளைச் செய்கிறார்.


A variable is bound to a specific type in the symbol table.

ஒரு மாறி சின்ன அட்டவணையில் ஒரு குறிப்பிட்ட வகையுடன் இணைக்கப்பட்டுள்ளது.


The function's return type must match the declared type.

செயல்பாட்டின் திரும்பும் வகை அறிவிக்கப்பட்ட வகையுடன் பொருந்த வேண்டும்.


The program is checked for type correctness.

நிரல் வகை சரியானதா என சரிபார்க்கப்படுகிறது.


Overloading allows the same name for different operations.

மேலோட்டம் வெவ்வேறு செயல்பாடுகளுக்கு ஒரே பெயரை அனுமதிக்கிறது.


Polymorphism enables functions to work with various data types.

பாலிமார்பிசம் பல்வேறு தரவு வகைகளுடன் செயல்பட செயல்பாடுகளை இயக்குகிறது.


Type inference algorithms deduce variable types automatically.

வகை அனுமான வழிமுறைகள் மாறி வகைகளை தானாகவே கழிக்கின்றன.


The compiler generates intermediate code for different architectures.

மொழிபெயர்ப்பாளர் வெவ்வேறு கட்டமைப்புகளுக்கு இடைநிலை குறியீட்டை உருவாக்குகிறார்.


The back-end translates intermediate code to machine code.

பின்புறம் இடைநிலை குறியீட்டை இயந்திரக் குறியீடாக மொழிபெயர்க்கிறது.


The design space of static vs. dynamic and weak vs. strong typing is complex.

நிலையான மற்றும் மாறும் மற்றும் பலவீனமான மற்றும் வலுவான தட்டச்சு செய்யும் வடிவமைப்பு இடம் சிக்கலானது.


The type checker function uses a notation similar to the concrete syntax.

வகை சரிபார்ப்பு செயல்பாடு கான்கிரீட் தொடரியலுக்கு ஒத்த ஒரு குறியீட்டைப் பயன்படுத்துகிறது.


The function reports a type error if the types do not match.

வகைகள் பொருந்தவில்லை என்றால், செயல்பாடு ஒரு வகை பிழையைப் புகாரளிக்கிறது.


The compiler optimizes the code for better performance.

சிறந்த செயல்திறனுக்காக மொழிபெயர்ப்பாளர் குறியீட்டை மேம்படுத்துகிறார்.


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.

இந்த வழியில், ஒவ்வொரு இயந்திரத்திற்கும் ஒரு தனி பின்-முனையை எழுத வேண்டிய அவசியம் இல்லை.


The advantages of this approach are: No actual back-end needs to be written for each new 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.

இந்த கலப்பின வடிவம் ஜஸ்ட்-இன்-டைம் தொகுப்பு என்று அழைக்கப்படுகிறது மற்றும் ஜாவாவிற்கான இடைநிலை குறியீட்டை இயக்குவதற்கு அடிக்கடி பயன்படுத்தப்படுகிறது.


We will in this book, however, focus mainly on using the intermediate code for traditional compilation.

இருப்பினும், இந்த புத்தகத்தில், பாரம்பரிய தொகுப்பிற்காக இடைநிலை குறியீட்டைப் பயன்படுத்துவதில் நாங்கள் முக்கியமாக கவனம் செலுத்துவோம்.


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.

இந்த அணுகுமுறைகளில் முதலாவது, இடைநிலை மொழி விளக்கப்படும்போது பெரும்பாலும் பயன்படுத்தப்படுகிறது.


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

ஒவ்வொரு சொற்றொடரியல் வகைகளுக்கும் மொழிபெயர்ப்பு செயல்பாடுகளைப் பயன்படுத்தி குறியீட்டை உருவாக்குவோம்.


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.

சில மொழிகள் சுழல்களை நடுவில் இருந்து வெளியேற அனுமதிக்கின்றன.


The translation function for statements must have an extra parameter.

அறிக்கைகளுக்கான மொழிபெயர்ப்பு செயல்பாடு ஒரு கூடுதல் அளவுருவைக் கொண்டிருக்க வேண்டும்.


Case-statements evaluate an expression and select branches.

கேஸ்-அறிக்கைகள் ஒரு வெளிப்பாட்டை மதிப்பிட்டு கிளைகளைத் தேர்ந்தெடுக்கின்றன.


We will now look at how these can be translated.

இப்போது இவற்றை எவ்வாறு மொழிபெயர்க்கலாம் என்பதைப் பார்ப்போம்.


Floating-point values are stored in different registers.

மிதவை புள்ளி மதிப்புகள் வெவ்வேறு பதிவேடுகளில் சேமிக்கப்படுகின்றன.


We use temporary variables to store intermediate expression results.

இடைநிலை வெளிப்பாட்டு முடிவுகளை சேமிக்க தற்காலிக மாறிகளைப் பயன்படுத்துகிறோம்.


The index used to access array elements must be multiplied.

அரே உறுப்புகளை அணுகப் பயன்படும் குறியீட்டை பெருக்க வேண்டும்.


We extend our example language with one-dimensional arrays.

ஒரு பரிமாண அரேக்களுடன் எங்கள் எடுத்துக்காட்டு மொழியை விரிவுபடுத்துகிறோம்.


தொகுப்பாளருக்கு ஒரு பெரிய முகவரி இடம் உள்ளது.


Dynamic allocation can also be done globally.

இயக்கவியல் ஒதுக்கீட்டை உலகளவில் செய்யலாம்.


Multi-dimensional arrays can be laid out in memory.

பல பரிமாண அரேக்களை நினைவகத்தில் அமைக்கலாம்.


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

சரம் பொதுவாக ஒரு பரிமாண அரேக்களைப் போலவே செயல்படுத்தப்படுகிறது.


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

மொழிபெயர்ப்புக்கு தேவையான தகவல்களை சின்ன அட்டவணை கொண்டுள்ளது என்பதை தொகுப்பி உறுதி செய்கிறது.


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

ஒரு மாறி அறிவிக்கப்படும்போது, தொகுப்பி சின்ன அட்டவணையில் தகவல்களைச் சேமிக்கிறது.


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

முழு எண் மாறிகளுக்கு, சின்ன அட்டவணை உள்ளீடு இடைநிலை மொழி மாறியை உள்ளடக்கியது.


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

அணி மாறிகளுக்கு சின்ன அட்டவணையில் அடிப்படை முகவரி மற்றும் பரிமாணங்கள் தேவை.


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

பதிவேடுகளுக்கு ஒவ்வொரு புலத்திற்கும் ஆஃப்செட்களும், சின்ன அட்டவணையில் மொத்த அளவும் தேவை.


The symbol table provides a type description for named types.

சின்ன அட்டவணை பெயரிடப்பட்ட வகைகளுக்கு ஒரு வகை விளக்கத்தை வழங்குகிறது.


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.

அத்தியாயம் 10 செயல்பாடு அறிவிப்புகளின் மொழிபெயர்ப்பை உள்ளடக்கும்.


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.

JVM சிக்கலான செயல்பாடுகளுக்கு ஒற்றை வழிமுறைகளைக் கொண்டுள்ளது.


JVM was originally intended for interpretation.

JVM முதலில் விளக்கத்திற்காக வடிவமைக்கப்பட்டது.


A program in JVM is validated before interpretation.

JVM இல் உள்ள ஒரு நிரல் விளக்கம் செய்வதற்கு முன் சரிபார்க்கப்படுகிறது.


The code is smaller because of complex operations being single instructions.

சிக்கலான செயல்பாடுகள் ஒற்றை வழிமுறைகளாக இருப்பதால் குறியீடு சிறியதாக உள்ளது.


The compiler optimizes code to improve performance.

செயல்திறனை மேம்படுத்த, தொகுப்பி குறியீட்டை மேம்படுத்துகிறது.


Register allocation is crucial for efficient code execution.

திறமையான குறியீடு செயல்படுத்தலுக்குப் பதிவேடு ஒதுக்கீடு முக்கியமானது.


Liveness analysis helps determine which variables are in use.

எந்த மாறிகள் பயன்பாட்டில் உள்ளன என்பதைத் தீர்மானிக்க உயிர்வாழ்வு பகுப்பாய்வு உதவுகிறது.


The interference graph shows which variables cannot share a register.

எந்த மாறிகள் ஒரு பதிவேட்டைப் பகிர்ந்து கொள்ள முடியாது என்பதை குறுக்கீட்டு வரைபடம் காட்டுகிறது.


Graph coloring is used to assign registers to variables.

மாறிகளுக்குப் பதிவேடுகளை ஒதுக்க வரைபட வண்ணம் பயன்படுத்தப்படுகிறது.


Optimizations can significantly reduce execution time.

மேம்படுத்தல்கள் செயல்படுத்தும் நேரத்தை கணிசமாகக் குறைக்கலாம்.


The program calculates the Fibonacci sequence.

நிரல் ஃபைபோனச்சி தொடரை கணக்கிடுகிறது.


Variables are mapped to registers during allocation.

ஒதுக்கீட்டின் போது மாறிகள் பதிவேடுகளுக்குப் பயன்படுத்தப்படுகின்றன.


The compiler generates machine code from intermediate code.

தொகுப்பி இடைநிலை குறியீட்டிலிருந்து இயந்திர குறியீட்டை உருவாக்குகிறது.


Understanding liveness is key to register allocation.

பதிவேடு ஒதுக்கீட்டிற்கு உயிர்வாழ்வைப் புரிந்துகொள்வது முக்கியம்.


The algorithm eliminates common subexpressions.

அல்காரிதம் பொதுவான துணை வெளிப்பாடுகளை நீக்குகிறது.


Code hoisting moves computations outside loops.

குறியீடு உயர்த்துதல் கணக்கீடுகளை சுழல்களுக்கு வெளியே நகர்த்துகிறது.


Constant propagation simplifies calculations.

நிலையான பரப்புதல் கணக்கீடுகளை எளிதாக்குகிறது.


Index-check elimination improves performance.

குறியீட்டு-சரிபார்ப்பு நீக்கம் செயல்திறனை மேம்படுத்துகிறது.


The intermediate language simplifies optimization.

இடைநிலை மொழி மேம்படுத்தலை எளிதாக்குகிறது.


Register allocation aims to use registers efficiently.

பதிவேடு ஒதுக்கீடு பதிவேடுகளை திறமையாகப் பயன்படுத்துவதை நோக்கமாகக் கொண்டுள்ளது.


Spilling occurs when there are not enough registers.

போதுமான பதிவேடுகள் இல்லாதபோது கசிவு ஏற்படுகிறது.


The program's output is displayed on the screen.

நிரலின் வெளியீடு திரையில் காட்டப்படும்.


பயனர் தவறான கடவுச்சொல்லை உள்ளிட்டுள்ளார்.


The company announced a new product launch.

நிறுவனம் ஒரு புதிய தயாரிப்பு வெளியீட்டை அறிவித்தது.


The algorithm helps in efficient register allocation.

இந்த வழிமுறை திறமையான பதிவேடு ஒதுக்கீட்டிற்கு உதவுகிறது.


Spilling is necessary when the register allocator cannot find a color for a node.

பதிவேடு ஒதுக்குபவர் ஒரு முனையின் நிறத்தைக் கண்டுபிடிக்க முடியாவிட்டால், கசிவு அவசியம்.


The program uses a stack for storing variables.

நிரல் மாறிகளை சேமிக்க ஒரு அடுக்கைப் பயன்படுத்துகிறது.


Function calls are translated into a call-sequence of instructions.

செயல்பாட்டு அழைப்புகள் அறிவுறுத்தல்களின் அழைப்பு-வரிசையாக மொழிபெயர்க்கப்படுகின்றன.


The activation record stores the return address.

செயல்பாட்டு பதிவு திரும்பும் முகவரியை சேமிக்கிறது.


We will look at this issue in chapter 10.

நாம் இந்த சிக்கலை 10 ஆம் அதிகாரத்தில் பார்ப்போம்.


The compiler textbooks show some other variants.

தொகுப்பி பாடப்புத்தகங்கள் வேறு சில வகைகளைக் காட்டுகின்றன.


இந்த செயல்முறை கசிவு என்று அழைக்கப்படுகிறது.


The stack can also be used for other purposes.

அடுக்கு மற்ற நோக்கங்களுக்காகவும் பயன்படுத்தப்படலாம்.


We can not hope to keep all these variables in registers.

இந்த எல்லா மாறிகளையும் பதிவேடுகளில் வைத்திருக்க முடியும் என்று நாங்கள் எதிர்பார்க்க முடியாது.


The basic idea is that only variables that are local to the active function will be kept in registers.

செயலில் உள்ள செயல்பாட்டிற்கு உள்ளூர் மாறிகள் மட்டுமே பதிவேடுகளில் வைக்கப்படும் என்பது அடிப்படை யோசனை.


Each function invocation will allocate a chunk of memory on the stack.

ஒவ்வொரு செயல்பாட்டு அழைப்பும் அடுக்கில் நினைவகத்தின் ஒரு பகுதியை ஒதுக்கும்.


This chunk is called the activation record or frame for the function invocation.

இந்த பகுதி செயல்பாட்டு அழைப்பிற்கான செயல்படுத்தும் பதிவு அல்லது சட்டகம் என்று அழைக்கப்படுகிறது.


Often, the machine architecture will dictate a calling convention.

பெரும்பாலும், இயந்திர கட்டமைப்பு அழைப்பு மரபை ஆணையிடும்.


We will start by defining very simple activation records.

மிகவும் எளிமையான செயல்படுத்தும் பதிவுகளை வரையறுப்பதன் மூலம் தொடங்குவோம்.


This includes parameters, return address and the contents of registers.

இது அளவுருக்கள், திரும்பும் முகவரி மற்றும் பதிவேடுகளின் உள்ளடக்கங்களை உள்ளடக்கியது.


A possible layout for such an activation record is shown in figure 10.1.

அத்தகைய செயல்படுத்தும் பதிவிற்கான ஒரு சாத்தியமான தளவமைப்பு படம் 10.1 இல் காட்டப்பட்டுள்ளது.


The function will typically move the parameters to registers.

செயல்பாடு பொதுவாக அளவுருக்களை பதிவேடுகளுக்கு நகர்த்தும்.


Above this, the incoming parameters are stored.

இதற்கு மேல், உள்வரும் அளவுருக்கள் சேமிக்கப்படுகின்றன.


This is called the prologue of the function.

இது செயல்பாட்டின் முன்னுரை என்று அழைக்கப்படுகிறது.


இன்று சூரியன் பிரகாசமாக பிரகாசிக்கிறது.


உப்பு கொஞ்சம் கொடுக்க முடியுமா?


I am going to the market to buy some vegetables.

நான் காய்கறிகள் வாங்க சந்தைக்குப் போகிறேன்.


The company announced its quarterly profits.

நிறுவனம் அதன் காலாண்டு லாபத்தை அறிவித்தது.


அவர் மிகவும் திறமையான இசைக்கலைஞர்.


The weather forecast predicts rain for tomorrow.

நாளை மழை பெய்யும் என்று வானிலை அறிக்கை கூறுகிறது.


Please submit your application before the deadline.

காலக்கெடுவிற்குள் உங்கள் விண்ணப்பத்தை சமர்ப்பிக்கவும்.


The new technology has revolutionized the industry.

புதிய தொழில்நுட்பம் தொழில்துறையில் புரட்சியை ஏற்படுத்தியுள்ளது.


She enjoys reading novels in her free time.

அவள் ஓய்வு நேரத்தில் நாவல்கள் படிப்பதை விரும்புகிறாள்.


The government is implementing new policies.

அரசு புதிய கொள்கைகளை அமல்படுத்துகிறது.


The algorithm efficiently sorts the data.

அல்காரிதம் தரவை திறமையாக வரிசைப்படுத்துகிறது.


அவர் பல மொழிகளில் சரளமாக பேசுகிறார்.


The research team made a significant discovery.

ஆராய்ச்சி குழு ஒரு குறிப்பிடத்தக்க கண்டுபிடிப்பை நிகழ்த்தியது.


The project requires careful planning and execution.

இந்த திட்டத்திற்கு கவனமாக திட்டமிடல் மற்றும் செயல்படுத்துதல் தேவை.


பொருளாதார நிலைமை இன்னும் நிச்சயமற்றதாக உள்ளது.


The software update includes several new features.

மென்பொருள் புதுப்பிப்பில் பல புதிய அம்சங்கள் உள்ளன.


She is a dedicated teacher who inspires her students.

அவள் தனது மாணவர்களுக்கு ஊக்கமளிக்கும் ஒரு அர்ப்பணிப்புள்ள ஆசிரியை.


The company is expanding its operations globally.

நிறுவனம் அதன் செயல்பாடுகளை உலகளவில் விரிவுபடுத்துகிறது.


The complex equation was difficult to solve.

சிக்கலான சமன்பாட்டை தீர்ப்பது கடினமாக இருந்தது.


The artist's work is displayed in a prestigious gallery.

கலைஞரின் படைப்புகள் மதிப்புமிக்க ஒரு கலைக்கூடத்தில் காட்சிப்படுத்தப்பட்டுள்ளன.


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

முதலில், மாறிகளை வைத்திருக்கப் பயன்படும் அனைத்து பதிவேடுகளும் சட்டகத்தில் சேமிக்கப்படுகின்றன.


In figure 10.3, R0-Rk are assumed to hold variables.

படம் 10.3 இல், R0-Rk மாறிகளை வைத்திருப்பதாகக் கருதப்படுகின்றன.


These are stored in the activation record just above the calling function’s own incoming parameters.

இவை அழைக்கும் செயல்பாட்டின் சொந்த உள்வரும் அளவுருக்களுக்கு மேலே உள்ள செயல்படுத்தும் பதிவில் சேமிக்கப்படுகின்றன.


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

பின்னர், சட்டகச் சுட்டி புதிய சட்டகத்தை நோக்கிச் செல்ல முன்னேறுகிறது.


The parameters and the return address are stored in the prescribed locations in 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 மாறிக்கு முடிவு படிக்கப்படுகிறது.


FP is restored to its former value and the saved registers are read back from the old frame.

FP அதன் முந்தைய மதிப்பிற்கு மீட்டமைக்கப்படுகிறது மற்றும் சேமிக்கப்பட்ட பதிவேடுகள் பழைய சட்டகத்திலிருந்து மீண்டும் படிக்கப்படுகின்றன.


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.

மாறாக, ஒவ்வொரு அளவுருவையும் மதிப்பிடப்பட்டவுடன் சட்டகத்தில் சேமிப்பதாகும்.


This way, only one of the variables a1,...,an will be live at any one time.

இந்த வழியில், எந்த நேரத்திலும் a1,...,an மாறிகளில் ஒன்று மட்டுமே உயிர்ப்புடன் இருக்கும்.


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

இருப்பினும், பிற்கால அளவுரு-வெளிப்பாடு ஒரு செயல்பாட்டு அழைப்பைக் கொண்டிருந்தால் இது தவறாகப் போகலாம்.


Hence, this optimisation 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.

இந்த எளிய அழைப்பு-வரிசையில், மாறிகளை வைத்திருக்கக்கூடிய அனைத்து பதிவேடுகளையும் அடுக்குக்கு சேமிக்கிறோம்.


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 in figure 10.1 is that, before a function is called, the caller saves all registers that must be preserved.

படம் 10.1 இல் உள்ள செயல்படுத்தும் பதிவு அமைப்பால் பயன்படுத்தப்படும் மரபு என்னவென்றால், ஒரு செயல்பாடு அழைக்கப்படுவதற்கு முன்பு, அழைப்பவர் பாதுகாக்கப்பட வேண்டிய அனைத்து பதிவேடுகளையும் சேமிக்கிறார்.


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

மாற்று உத்தி என்னவென்றால், அழைக்கப்படும் செயல்பாடு பாதுகாக்கப்பட வேண்டிய பதிவேடுகளின் உள்ளடக்கங்களைச் சேமிக்கிறது.


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

அழைப்பவர்-சேமிப்புகள் நேரடி மாறிகளை வைத்திருக்கும் பதிவேடுகளை மட்டுமே சேமிக்க வேண்டும்.


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

ஒவ்வொரு செயல்பாடும் சுதந்திரமாக தொகுக்கப்படுவதால், இந்த தேவையற்ற சேமிப்புகளை நாம் தவிர்க்க முடியாது.


இன்று வானிலை நன்றாக உள்ளது.


உப்பு கொஞ்சம் கொடுக்க முடியுமா?


I am going to the market to buy some vegetables.

நான் காய்கறிகள் வாங்க சந்தைக்குப் போகிறேன்.


The company announced a new product launch.

நிறுவனம் ஒரு புதிய தயாரிப்பு வெளியீட்டை அறிவித்தது.


அவர் மிகவும் திறமையான இசைக்கலைஞர்.


The government is implementing new policies.

அரசு புதிய கொள்கைகளை அமல்படுத்துகிறது.


The research team conducted several experiments.

ஆராய்ச்சி குழு பல சோதனைகளை நடத்தியது.


She enjoys reading novels in her free time.

அவள் தனது ஓய்வு நேரத்தில் நாவல்கள் படிப்பதை விரும்புகிறாள்.


The economic situation is improving gradually.

பொருளாதார நிலை படிப்படியாக மேம்பட்டு வருகிறது.


Please submit your application before the deadline.

கடைசி தேதிக்கு முன் உங்கள் விண்ணப்பத்தை சமர்ப்பிக்கவும்.


The algorithm efficiently sorts the data.

அல்காரிதம் தரவை திறமையாக வரிசைப்படுத்துகிறது.


சவால்கள் இருந்தபோதிலும், அவர்கள் வெற்றி பெற்றனர்.


அடுத்த மாதம் மாநாடு நடைபெறும்.


The impact of climate change is significant.

காலநிலை மாற்றத்தின் தாக்கம் குறிப்பிடத்தக்கது.


மென்பொருள் அடிக்கடி புதுப்பிப்புகளைக் கோருகிறது.


அவர் தனது துறையில் புகழ்பெற்ற நிபுணர்.


The project's success depends on teamwork.

திட்டத்தின் வெற்றி குழுப்பணியைப் பொறுத்தது.


The data analysis revealed interesting insights.

தரவு பகுப்பாய்வு சுவாரஸ்யமான நுண்ணறிவுகளை வெளிப்படுத்தியது.


அவள் பல மொழிகளில் சரளமாக பேசுகிறாள்.


The company is expanding its operations globally.

நிறுவனம் தனது செயல்பாடுகளை உலகளவில் விரிவுபடுத்துகிறது.


இன்று வானிலை நன்றாக உள்ளது.


உப்பு கொஞ்சம் கொடுங்களேன்.


I am going to the market to buy some groceries.

நான் மளிகை பொருட்கள் வாங்க கடைக்கு செல்கிறேன்.


The company announced its quarterly profits.

நிறுவனம் அதன் காலாண்டு லாபத்தை அறிவித்தது.


அவர் மிகவும் திறமையான இசைக்கலைஞர்.


அரசு புதிய கொள்கைகளை அமல்படுத்துகிறது.


The research team is working on a new project.

ஆராய்ச்சி குழு ஒரு புதிய திட்டத்தில் பணிபுரிந்து வருகிறது.


அவள் சரளமாக ஆங்கிலமும் தமிழும் பேசுகிறாள்.


The price of petrol has increased recently.

பெட்ரோல் விலை சமீபத்தில் அதிகரித்துள்ளது.


அடுத்த மாதம் மாநாடு நடைபெறும்.


நிறுவனம் அதன் செயல்பாடுகளை உலகளவில் விரிவுபடுத்துகிறது.


The complex system requires careful analysis.

சிக்கலான அமைப்பு கவனமாக பகுப்பாய்வு செய்யப்பட வேண்டும்.


அவர் தனது துறையில் புகழ்பெற்ற நிபுணர்.


The economic forecast predicts a recession.

பொருளாதார முன்னறிவிப்பு ஒரு மந்தநிலையை முன்னறிவிக்கிறது.


The software update includes several bug fixes.

மென்பொருள் புதுப்பிப்பில் பல பிழை திருத்தங்கள் உள்ளன.


The artist's work is displayed in the museum.

கலைஞரின் படைப்பு அருங்காட்சியகத்தில் காட்சிப்படுத்தப்பட்டுள்ளது.


The project's success depends on collaboration.

திட்டத்தின் வெற்றி ஒத்துழைப்பை பொறுத்தது.


The garbage collector moves live objects to a new space.

கழிவுகளைச் சேகரிப்பவர் உயிரோடிருக்கும் பொருட்களை ஒரு புதிய இடத்திற்கு நகர்த்துகிறார்.


Generational collectors divide the heap into different spaces.

தலைமுறை சேகரிப்பவர்கள் குவியலை வெவ்வேறு இடங்களாகப் பிரிக்கிறார்கள்.


The program needs to react quickly to outside changes.

நிகழ்ச்சி வெளிப்புற மாற்றங்களுக்கு விரைவாகப் பிரதிபலிக்க வேண்டும்.


Automatic memory management is a key feature.

தானியங்கி நினைவக மேலாண்மை ஒரு முக்கிய அம்சமாகும்.


The compiler translates code from one language to another.

தொகுப்பி ஒரு மொழியிலிருந்து இன்னொரு மொழிக்குக் குறியீட்டை மொழிபெயர்க்கிறது.


Bootstrapping is a technique used in compiler design.

தொடக்கநிலை என்பது தொகுப்பி வடிவமைப்பில் பயன்படுத்தப்படும் ஒரு நுட்பமாகும்.


The machine directly executes language D.

இயந்திரம் நேரடியாக மொழி D ஐ இயக்குகிறது.


தொகுப்பி மொழி B இல் எழுதப்பட்டுள்ளது.


இந்த செயல்முறை பூட்ஸ்டிராப்பிங் என்று அழைக்கப்படுகிறது.


நிரல் இயந்திரத்தில் இயங்குகிறது.


The compiler generates ARM machine code.

தொகுப்பி ARM இயந்திரக் குறியீட்டை உருவாக்குகிறது.


We want a compiler for ML to x86 machine code.

ML இலிருந்து x86 இயந்திரக் குறியீட்டிற்கான ஒரு தொகுப்பி எங்களுக்கு வேண்டும்.


தொகுப்பி தன்னைத் தானே தொகுக்க முடியும்.


இது ஒரு சிக்கலான செயல்முறை.


புதிய தொகுப்பி மிகவும் திறமையானது.


நிரல் மொழி A இல் எழுதப்பட்டுள்ளது.


The interpreter is running on a machine.

விளக்குனர் ஒரு இயந்திரத்தில் இயங்குகிறது.


The source program is shown at the left.

மூல நிரல் இடதுபுறத்தில் காட்டப்பட்டுள்ளது.


The target program is shown on the right.

இலக்கு நிரல் வலதுபுறத்தில் காட்டப்பட்டுள்ளது.


The compiler is a crucial tool for software development.

தொகுப்பி மென்பொருள் உருவாக்கத்திற்கு ஒரு முக்கியமான கருவியாகும்.


The compiler translates code into machine instructions.

கம்ப்யூட்டர் குறியீட்டை இயந்திர வழிமுறைகளாக மொழிபெயர்க்கிறது.


Bootstrapping is a crucial process in compiler design.

கம்ப்யூட்டர் வடிவமைப்பில் பூட்ஸ்டிராப்பிங் ஒரு முக்கியமான செயல்முறையாகும்.


The QAD compiler is used as an initial step.

QAD கம்பைலர் ஆரம்ப கட்டமாகப் பயன்படுத்தப்படுகிறது.


நாங்கள் M+ என்று அழைக்கப்படும் ஒரு புதிய மொழியை வடிவமைக்கிறோம்.


The real compiler is written in the new language.

உண்மையான கம்பைலர் புதிய மொழியில் எழுதப்பட்டுள்ளது.


The generated code can run on an existing platform.

உருவாக்கப்பட்ட குறியீடு ஏற்கனவே உள்ள தளத்தில் இயங்க முடியும்.


The QAD compiler does not need to generate good code.

QAD கம்பைலர் நல்ல குறியீட்டை உருவாக்க வேண்டியதில்லை.


The important thing is that it allows programs to be executed.

முக்கியமான விஷயம் என்னவென்றால், இது நிரல்களை இயக்க அனுமதிக்கிறது.


The 'real' compiler will be bootstrapped using the QAD compiler.

உண்மையான கம்பைலர் QAD கம்பைலரைப் பயன்படுத்தி பூட்ஸ்டிராப் செய்யப்படும்.


Let us assume we design a new language 'M+'.

நாம் 'M+' என்ற புதிய மொழியை வடிவமைக்கிறோம் என்று வைத்துக்கொள்வோம்.


We initially write a compiler from M+ to ML in ML.

ஆரம்பத்தில், M+ இலிருந்து ML க்கு ML இல் ஒரு கம்பைலரை எழுதுகிறோம்.


The first step is to compile this, so it can run on some machine.

முதல் படி இதைத் தொகுப்பது, அதனால் அது சில இயந்திரங்களில் இயங்க முடியும்.


The QAD compiler can now be used to compile the 'real' compiler.

QAD கம்பைலரை இப்போது 'உண்மையான' கம்பைலரைத் தொகுக்கப் பயன்படுத்தலாம்.


The result is an ML program, which we need to compile.

இதன் விளைவாக ஒரு ML நிரல் உள்ளது, அதை நாம் தொகுக்க வேண்டும்.


This yields a compiler with the same functionality.

இது அதே செயல்பாட்டைக் கொண்ட ஒரு கம்பைலரை உருவாக்குகிறது.


It will generate the same code, but run faster.

இது அதே குறியீட்டை உருவாக்கும், ஆனால் வேகமாக இயங்கும்.


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

சரியான செயல்பாட்டைக் கொண்ட ஒரு கம்பைலர் கிடைத்தாலும், பூட்ஸ்டிராப்பிங் முழுமையடையாமல் போகலாம்.


Instead of writing a QAD compiler, we can write a QAD interpreter.

QAD கம்பைலரை எழுதுவதற்குப் பதிலாக, நாம் ஒரு QAD மொழிபெயர்ப்பாளரை எழுதலாம்.


We can then use this to run the M+ compiler directly.

பின்னர் இதை M+ கம்பைலரை நேரடியாக இயக்கப் பயன்படுத்தலாம்.


Though using an interpreter requires fewer steps, this should not really be a consideration.

ஒரு மொழிபெயர்ப்பாளரைப் பயன்படுத்துவது குறைவான படிகளை எடுத்தாலும், இது உண்மையில் ஒரு கருத்தாக இருக்கக்கூடாது.


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.1(b) இல் உள்ள 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 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.

நண்பர் பயன்பாட்டில் இல்லை என்றால் (இரட்டை அளவு புலத்தைக் கொண்டிருப்பதன் மூலம் குறிக்கப்படுகிறது) மற்றும் விடுவிக்கப்பட்ட தொகுதியின் அதே அளவாக இருந்தால், குறைந்த முகவரியைக் கொண்ட நண்பரின் அளவு புலத்தில் அளவை இரட்டிப்பாக்குவதன் மூலம் இரண்டு தொகுதிகளையும் இணைக்கிறோம்.


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

ஏற்கனவே இலவசமாக உள்ள நண்பரை அதன் இலவச பட்டியலிலிருந்து அகற்றி, இணைக்கப்பட்ட தொகுதியை அடுத்த இலவச பட்டியலில் சேர்க்கிறோம்.


கருத்துகள் உள்ளே அமைந்தவை.


Common subexpression elimination is a key optimization technique.

பொதுவான துணை வெளிப்பாடுகளை நீக்குவது ஒரு முக்கிய உகப்பாக்க நுட்பமாகும்.


தொகுப்பில் பல நிலைகள் உள்ளன.


Compile-time errors are caught during the compilation phase.

தொகுப்பு நேரத்தில் ஏற்படும் பிழைகள் தொகுப்பு கட்டத்தில் கண்டறியப்படுகின்றன.


தொகுப்பாளர்களைத் தொகுப்பது ஒரு சிக்கலான பணியாகும்.


பகுப்பாய்வில் முரண்பாடுகள் ஏற்படலாம்.


Reduce-reduce conflicts need careful handling.

குறை-குறை மோதல்களை கவனமாக கையாள வேண்டும்.


Shift-reduce conflicts are common in parser design.

நகர்வு-குறை மோதல்கள் பகுப்பாய்வி வடிவமைப்பில் பொதுவானவை.


ஒரு நிலையான அணுகுமுறை முக்கியமானது.


Constant propagation is an optimization technique.

நிலையான பரப்புதல் ஒரு உகப்பாக்க நுட்பமாகும்.


Context-free grammars are fundamental to compiler design.

சூழல்-இலவச இலக்கணங்கள் தொகுப்பி வடிவமைப்பிற்கு அடிப்படையானவை.


The dangling-else problem is a classic parsing ambiguity.

தொங்கு-இல்லையெனில் பிரச்சனை ஒரு உன்னதமான பகுப்பாய்வு தெளிவின்மை ஆகும்.


Data-flow analysis helps in optimization.

தரவு-ஓட்ட பகுப்பாய்வு உகப்பாக்கத்திற்கு உதவுகிறது.


Dead code elimination removes unnecessary code.

செயலற்ற குறியீடு நீக்கம் தேவையற்ற குறியீட்டை நீக்குகிறது.


ஒரு அறிவிப்பு ஒரு மாறியை அறிமுகப்படுத்துகிறது.


Derivation is a key concept in grammars.

பெறுதல் இலக்கணங்களில் ஒரு முக்கிய கருத்தாகும்.


DFA சொற்கள் பகுப்பாய்வில் பயன்படுத்தப்படுகிறது.


Converting NFA to DFA is a standard process.

NFA ஐ DFA ஆக மாற்றுவது ஒரு நிலையான செயல்முறையாகும்.


Domain-specific languages are designed for specific tasks.

கள-குறிப்பிட்ட மொழிகள் குறிப்பிட்ட பணிகளுக்காக வடிவமைக்கப்பட்டுள்ளன.


Dynamic programming can be used for optimization.

மாறும் நிரலாக்கத்தை உகப்பாக்கத்திற்கு பயன்படுத்தலாம்.