ਇੱਕ ਕੰਪਾਈਲਰ ਕੀ ਹੈ?


ਇੱਕ ਕੰਪਾਈਲਰ ਦੇ ਪੜਾਅ ਮਹੱਤਵਪੂਰਨ ਹਨ।


Interpreters are also used in programming.

ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਿੱਚ ਇੰਟਰਪ੍ਰੇਟਰਾਂ ਦੀ ਵੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


ਕੰਪਾਈਲਰਾਂ ਬਾਰੇ ਕਿਉਂ ਸਿੱਖੀਏ?


This book is about the basics of compiler design.

ਇਹ ਕਿਤਾਬ ਕੰਪਾਈਲਰ ਡਿਜ਼ਾਈਨ ਦੀਆਂ ਮੁਢਲੀਆਂ ਗੱਲਾਂ ਬਾਰੇ ਹੈ।


The lecturer should be aware of the book's structure.

ਲੈਕਚਰਾਰ ਨੂੰ ਕਿਤਾਬ ਦੇ ਢਾਂਚੇ ਬਾਰੇ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


We acknowledge the contributions of many.

ਅਸੀਂ ਕਈਆਂ ਦੇ ਯੋਗਦਾਨ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਾਂ।


Permission to use this material is granted.

ਇਸ ਸਮੱਗਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਗਈ ਹੈ।


ਸ਼ਬਦ-ਕੋਸ਼ ਵਿਸ਼ਲੇਸ਼ਣ ਪਹਿਲਾ ਕਦਮ ਹੈ।


Regular expressions are used for pattern matching.

ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਪੈਟਰਨ ਮੈਚਿੰਗ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


Shorthands can simplify regular expressions.

ਸੰਖੇਪ ਰੂਪ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਨੂੰ ਸਰਲ ਬਣਾ ਸਕਦੇ ਹਨ।


ਆਓ ਕੁਝ ਉਦਾਹਰਣਾਂ ਵੇਖੀਏ।


Nondeterministic finite automata are important.

ਗੈਰ-ਨਿਰਧਾਰਤ ਸੀਮਤ ਆਟੋਮੈਟਾ ਮਹੱਤਵਪੂਰਨ ਹਨ।


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

ਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ ਨੂੰ NFA ਵਿੱਚ ਬਦਲਣਾ ਇੱਕ ਮੁੱਖ ਪ੍ਰਕਿਰਿਆ ਹੈ।


ਅਨੁਕੂਲਤਾ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੀ ਹੈ।


Deterministic finite automata are also used.

ਨਿਰਧਾਰਤ ਸੀਮਤ ਆਟੋਮੈਟਾ ਦੀ ਵੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


Converting an NFA to a DFA is a crucial step.

ਇੱਕ NFA ਨੂੰ DFA ਵਿੱਚ ਬਦਲਣਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ।


Solving set equations is part of the process.

ਸੈੱਟ ਸਮੀਕਰਨਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਪ੍ਰਕਿਰਿਆ ਦਾ ਹਿੱਸਾ ਹੈ।


The subset construction is a key algorithm.

ਉਪ-ਸਮੂਹ ਨਿਰਮਾਣ ਇੱਕ ਮੁੱਖ ਐਲਗੋਰਿਦਮ ਹੈ।


Size versus speed is an important consideration.

ਆਕਾਰ ਬਨਾਮ ਗਤੀ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਵਿਚਾਰ ਹੈ।


ਪ੍ਰੋਗਰਾਮ ਕੋਡ ਨੂੰ ਕੰਪਾਇਲ ਕਰੇਗਾ।


ਕਿਰਪਾ ਕਰਕੇ ਆਪਣਾ ਉਪਭੋਗਤਾ ਨਾਮ ਦਰਜ ਕਰੋ।


ਅੱਜ ਮੌਸਮ ਬਹੁਤ ਸੁਹਾਵਣਾ ਹੈ।


ਉਹ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਇੱਕ ਕਿਤਾਬ ਪੜ੍ਹ ਰਹੀ ਹੈ।


ਮੈਨੂੰ ਕੁਝ ਕਰਿਆਨੇ ਦਾ ਸਮਾਨ ਖਰੀਦਣ ਦੀ ਲੋੜ ਹੈ।


ਕੰਪਨੀ ਨੇ ਇੱਕ ਨਵੇਂ ਉਤਪਾਦ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


ਉਹ ਇਸ ਖੇਤਰ ਵਿੱਚ ਇੱਕ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਲੇਖਕ ਹੈ।


The government is discussing new policies.

ਸਰਕਾਰ ਨਵੀਂਆਂ ਨੀਤੀਆਂ 'ਤੇ ਚਰਚਾ ਕਰ ਰਹੀ ਹੈ।


The research team conducted an experiment.

ਖੋਜ ਟੀਮ ਨੇ ਇੱਕ ਪ੍ਰਯੋਗ ਕੀਤਾ।


ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਉਹ ਸਫਲ ਹੋਏ।


The complex system requires careful analysis.

ਗੁੰਝਲਦਾਰ ਪ੍ਰਣਾਲੀ ਨੂੰ ਧਿਆਨ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਲੋੜ ਹੈ।


The economic forecast predicts a recession.

ਆਰਥਿਕ ਭਵਿੱਖਬਾਣੀ ਇੱਕ ਮੰਦੀ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦੀ ਹੈ।


The philosophical debate explored existentialism.

ਦਾਰਸ਼ਨਿਕ ਬਹਿਸ ਨੇ ਹੋਂਦਵਾਦ ਦੀ ਪੜਚੋਲ ਕੀਤੀ।


The intricate design was meticulously crafted.

ਗੁੰਝਲਦਾਰ ਡਿਜ਼ਾਈਨ ਨੂੰ ਬਾਰੀਕੀ ਨਾਲ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ।


The implications of the treaty are far-reaching.

ਸੰਧੀ ਦੇ ਪ੍ਰਭਾਵ ਦੂਰ-ਦੂਰ ਤੱਕ ਫੈਲੇ ਹੋਏ ਹਨ।


The algorithm's efficiency is paramount for large datasets.

ਵੱਡੇ ਡੇਟਾਸੈੱਟਾਂ ਲਈ ਐਲਗੋਰਿਦਮ ਦੀ ਕੁਸ਼ਲਤਾ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The company's strategic decisions will impact future growth.

ਕੰਪਨੀ ਦੇ ਰਣਨੀਤਕ ਫੈਸਲੇ ਭਵਿੱਖੀ ਵਿਕਾਸ ਨੂੰ ਪ੍ਰਭਾਵਤ ਕਰਨਗੇ।


The nuances of the argument were difficult to grasp.

ਦਲੀਲ ਦੀਆਂ ਬਾਰੀਕੀਆਂ ਨੂੰ ਸਮਝਣਾ ਮੁਸ਼ਕਲ ਸੀ।


The theoretical framework provides a basis for understanding the phenomenon.

ਸਿਧਾਂਤਕ ਢਾਂਚਾ ਵਰਤਾਰੇ ਨੂੰ ਸਮਝਣ ਦਾ ਅਧਾਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


The compiler translates high-level code into machine language.

ਕੰਪਾਈਲਰ ਉੱਚ-ਪੱਧਰੀ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨੀ ਭਾਸ਼ਾ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ।


Lexical analysis divides the text into tokens.

ਲੈਕਸੀਕਲ ਵਿਸ਼ਲੇਸ਼ਣ ਟੈਕਸਟ ਨੂੰ ਟੋਕਨਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ।


Syntax analysis creates a tree structure.

ਸਿੰਟੈਕਸ ਵਿਸ਼ਲੇਸ਼ਣ ਇੱਕ ਟ੍ਰੀ ਢਾਂਚਾ ਬਣਾਉਂਦਾ ਹੈ।


Type checking ensures the program's consistency.

ਟਾਈਪ ਚੈਕਿੰਗ ਪ੍ਰੋਗਰਾਮ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ।


A compiler is essential for software development.

ਸਾਫਟਵੇਅਰ ਵਿਕਾਸ ਲਈ ਇੱਕ ਕੰਪਾਈਲਰ ਜ਼ਰੂਰੀ ਹੈ।


The program is written in a high-level language.

ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਉੱਚ-ਪੱਧਰੀ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ।


The compiler attempts to spot programmer mistakes.

ਕੰਪਾਈਲਰ ਪ੍ਰੋਗਰਾਮਰ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਲੱਭਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।


High-level languages are closer to human thought.

ਉੱਚ-ਪੱਧਰੀ ਭਾਸ਼ਾਵਾਂ ਮਨੁੱਖੀ ਵਿਚਾਰਾਂ ਦੇ ਨੇੜੇ ਹਨ।


The same program can run on different machines.

ਇੱਕੋ ਪ੍ਰੋਗਰਾਮ ਵੱਖ-ਵੱਖ ਮਸ਼ੀਨਾਂ 'ਤੇ ਚੱਲ ਸਕਦਾ ਹੈ।


ਚੰਗੇ ਕੰਪਾਈਲਰ ਗਤੀ ਲਈ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦੇ ਹਨ।


The compilation process is divided into phases.

ਕੰਪਾਈਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਪੜਾਵਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ।


Each phase has a well-defined interface.

ਹਰੇਕ ਪੜਾਅ ਦਾ ਇੱਕ ਚੰਗੀ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਇੰਟਰਫੇਸ ਹੁੰਦਾ ਹੈ।


Some modules are shared between compilers.

ਕੁਝ ਮੋਡੀਊਲ ਕੰਪਾਈਲਰਾਂ ਵਿੱਚ ਸਾਂਝੇ ਹੁੰਦੇ ਹਨ।


The lexical analyzer reads and analyzes the program text.

ਲੈਕਸੀਕਲ ਵਿਸ਼ਲੇਸ਼ਕ ਪ੍ਰੋਗਰਾਮ ਦੇ ਟੈਕਸਟ ਨੂੰ ਪੜ੍ਹਦਾ ਅਤੇ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ।


Syntax trees reflect the structure of the program.

ਸਿੰਟੈਕਸ ਟ੍ਰੀ ਪ੍ਰੋਗਰਾਮ ਦੀ ਬਣਤਰ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ।


Type checking identifies consistency requirements.

ਟਾਈਪ ਚੈਕਿੰਗ ਇਕਸਾਰਤਾ ਦੀਆਂ ਲੋੜਾਂ ਦੀ ਪਛਾਣ ਕਰਦੀ ਹੈ।


The compiler translates the high-level language into machine code, which the computer can execute.

ਕੰਪਾਈਲਰ ਉੱਚ-ਪੱਧਰੀ ਭਾਸ਼ਾ ਨੂੰ ਮਸ਼ੀਨੀ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ, ਜਿਸਨੂੰ ਕੰਪਿਊਟਰ ਚਲਾ ਸਕਦਾ ਹੈ।


During compilation, the compiler attempts to identify and report programmer errors.

ਕੰਪਾਈਲੇਸ਼ਨ ਦੌਰਾਨ, ਕੰਪਾਈਲਰ ਪ੍ਰੋਗਰਾਮਰ ਦੀਆਂ ਗਲਤੀਆਂ ਦੀ ਪਛਾਣ ਕਰਨ ਅਤੇ ਰਿਪੋਰਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।


A compiler bridges the gap between high-level programming languages and the low-level machine language.

ਇੱਕ ਕੰਪਾਈਲਰ ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਅਤੇ ਘੱਟ-ਪੱਧਰੀ ਮਸ਼ੀਨੀ ਭਾਸ਼ਾ ਦੇ ਵਿਚਕਾਰ ਪਾੜੇ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ।


The phases of a compiler are often interleaved in practice, even though they are conceptually sequential.

ਇੱਕ ਕੰਪਾਈਲਰ ਦੇ ਪੜਾਅ ਅਕਸਰ ਅਮਲ ਵਿੱਚ ਆਪਸ ਵਿੱਚ ਜੁੜੇ ਹੁੰਦੇ ਹਨ, ਭਾਵੇਂ ਕਿ ਉਹ ਸੰਕਲਪਿਕ ਤੌਰ 'ਤੇ ਕ੍ਰਮਵਾਰ ਹੁੰਦੇ ਹਨ।


The compiler translates the code into machine language.

ਕੰਪਾਈਲਰ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨੀ ਭਾਸ਼ਾ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ।


Lexical analysis is the first phase of compilation.

ਲੈਕਸੀਕਲ ਵਿਸ਼ਲੇਸ਼ਣ ਕੰਪਾਈਲੇਸ਼ਨ ਦਾ ਪਹਿਲਾ ਪੜਾਅ ਹੈ।


ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਸਿੰਟੈਕਸ ਗਲਤੀ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਿਆ।


ਇੰਟਰਪ੍ਰੇਟਰ ਕੋਡ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਲਾਈਨ ਚਲਾਉਂਦੇ ਹਨ।


Understanding compilers helps programmers write better code.

ਕੰਪਾਈਲਰਾਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ ਬਿਹਤਰ ਕੋਡ ਲਿਖਣ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ।


The front end of the compiler handles lexical and syntax analysis.

ਕੰਪਾਈਲਰ ਦਾ ਫਰੰਟ ਐਂਡ ਲੈਕਸੀਕਲ ਅਤੇ ਸਿੰਟੈਕਸ ਵਿਸ਼ਲੇਸ਼ਣ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।


Regular expressions are used for pattern matching in lexical analysis.

ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੀ ਵਰਤੋਂ ਲੈਕਸੀਕਲ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਪੈਟਰਨ ਮੈਚਿੰਗ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The back end of the compiler generates machine code.

ਕੰਪਾਈਲਰ ਦਾ ਬੈਕ ਐਂਡ ਮਸ਼ੀਨੀ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।


A compiler transforms source code into an executable form.

ਇੱਕ ਕੰਪਾਈਲਰ ਸਰੋਤ ਕੋਡ ਨੂੰ ਇੱਕ ਕਾਰਜਕਾਰੀ ਰੂਪ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।


The intermediate code is optimized before generating machine code.

ਮਸ਼ੀਨੀ ਕੋਡ ਤਿਆਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਿਚਕਾਰਲੇ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ।


The teacher explained the concept of compilation.

ਅਧਿਆਪਕ ਨੇ ਕੰਪਾਈਲੇਸ਼ਨ ਦੀ ਧਾਰਨਾ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ।


She is learning about compiler design in her computer science class.

ਉਹ ਆਪਣੀ ਕੰਪਿਊਟਰ ਸਾਇੰਸ ਕਲਾਸ ਵਿੱਚ ਕੰਪਾਈਲਰ ਡਿਜ਼ਾਈਨ ਬਾਰੇ ਸਿੱਖ ਰਹੀ ਹੈ।


The students are working on a compiler project.

ਵਿਦਿਆਰਥੀ ਇੱਕ ਕੰਪਾਈਲਰ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹਨ।


He needs to understand the different phases of a compiler.

ਉਸਨੂੰ ਇੱਕ ਕੰਪਾਈਲਰ ਦੇ ਵੱਖ-ਵੱਖ ਪੜਾਵਾਂ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ।


The book provides a detailed explanation of compiler construction.

ਕਿਤਾਬ ਕੰਪਾਈਲਰ ਨਿਰਮਾਣ ਦੀ ਵਿਸਤ੍ਰਿਤ ਵਿਆਖਿਆ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ।


The software engineer is debugging the compiler.

ਸਾਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰ ਕੰਪਾਈਲਰ ਨੂੰ ਡੀਬੱਗ ਕਰ ਰਿਹਾ ਹੈ।


The company is developing a new compiler for their programming language.

ਕੰਪਨੀ ਆਪਣੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਲਈ ਇੱਕ ਨਵਾਂ ਕੰਪਾਈਲਰ ਵਿਕਸਤ ਕਰ ਰਹੀ ਹੈ।


The performance of the program depends on the compiler's optimization.

ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਕੰਪਾਈਲਰ ਦੇ ਅਨੁਕੂਲਤਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।


The compiler course is very challenging.

ਕੰਪਾਈਲਰ ਕੋਰਸ ਬਹੁਤ ਚੁਣੌਤੀਪੂਰਨ ਹੈ।


The professor is an expert in compiler design.

ਪ੍ਰੋਫੈਸਰ ਕੰਪਾਈਲਰ ਡਿਜ਼ਾਈਨ ਦੇ ਮਾਹਰ ਹਨ।


This is now entered into the set S' of DFA states as unmarked.

ਇਹ ਹੁਣ DFA ਸਟੇਟਸ ਦੇ ਸੈੱਟ S' ਵਿੱਚ ਅਣਚਿੰਨ੍ਹਿਤ ਵਜੋਂ ਦਾਖਲ ਕੀਤਾ ਗਿਆ ਹੈ।


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 ਦੀ ਇਕਲੌਤੀ ਸਵੀਕਾਰਯੋਗ ਸਟੇਟ ਹੈ।


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.

ਇਸ ਤਰੀਕੇ ਨਾਲ NFA ਦੇ ਵਰਗਾਂ ਦਾ ਨਿਰਮਾਣ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ ਜੋ DFA ਵਿੱਚ ਤਬਦੀਲ ਹੋਣ 'ਤੇ ਘਾਤਕ ਤੌਰ 'ਤੇ ਫੈਲਦੇ ਹਨ।


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.

ਕਿਉਂਕਿ ਅਸੀਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਉਨ੍ਹਾਂ NFA ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਾਂ ਜੋ ਸੈਕਸ਼ਨ 2.4 ਵਿੱਚ ਦੱਸੇ ਗਏ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਤੋਂ ਬਣਾਏ ਗਏ ਹਨ, ਅਸੀਂ ਆਪਣੇ ਆਪ ਤੋਂ ਪੁੱਛ ਸਕਦੇ ਹਾਂ ਕਿ ਕੀ ਇਹ ਇੱਕ ਢੁਕਵੇਂ ਸਧਾਰਨ ਵਰਗ ਵਿੱਚ ਨਹੀਂ ਹੋ ਸਕਦੇ ਜੋ ਘਾਤਕ ਆਕਾਰ ਦੇ 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| ਇਨਪੁਟ ਸਟ੍ਰਿੰਗ v ਦੀ ਲੰਬਾਈ ਹੈ ਅਤੇ k ਇੱਕ ਛੋਟਾ ਸਥਿਰ ਹੈ ਜੋ DFA ਦੇ ਆਕਾਰ ਤੋਂ ਸੁਤੰਤਰ ਹੈ 1।


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 ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ।


Nevertheless, minimising a DFA is not terribly difficult and can be done fairly fast, so many lexer generators perform minimisation.

ਫਿਰ ਵੀ, ਇੱਕ DFA ਨੂੰ ਘੱਟੋ-ਘੱਟ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ ਅਤੇ ਕਾਫ਼ੀ ਤੇਜ਼ੀ ਨਾਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਬਹੁਤ ਸਾਰੇ ਲੇਕਸਰ ਜਨਰੇਟਰ ਘੱਟੋ-ਘੱਟਕਰਨ ਕਰਦੇ ਹਨ।


An accepting state is not equivalent to a non-accepting state.

ਇੱਕ ਸਵੀਕਾਰਯੋਗ ਸਟੇਟ ਇੱਕ ਗੈਰ-ਸਵੀਕਾਰਯੋਗ ਸਟੇਟ ਦੇ ਬਰਾਬਰ ਨਹੀਂ ਹੈ।


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 ਵੱਖਰੇ ਹਨ।


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

ਅਸੀਂ ਦੋ ਸਮੂਹਾਂ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਦੇ ਹਾਂ: ਸਵੀਕਾਰਯੋਗ ਸਟੇਟਾਂ ਦਾ ਸੈੱਟ F ਅਤੇ ਗੈਰ-ਸਵੀਕਾਰਯੋਗ ਸਟੇਟਾਂ ਦਾ ਸੈੱਟ S\F।


If G is not consistent, we split it into maximal consistent subgroups and replace G by these.

ਜੇਕਰ G ਇਕਸਾਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਇਕਸਾਰ ਉਪ-ਸਮੂਹਾਂ ਵਿੱਚ ਵੰਡਦੇ ਹਾਂ ਅਤੇ G ਨੂੰ ਇਹਨਾਂ ਨਾਲ ਬਦਲਦੇ ਹਾਂ।


The starting state of the minimal DFA is the group that contains the original starting state and any group of accepting states is an accepting state in the minimal DFA.

ਘੱਟੋ-ਘੱਟ DFA ਦੀ ਸ਼ੁਰੂਆਤੀ ਸਟੇਟ ਉਹ ਸਮੂਹ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸਲ ਸ਼ੁਰੂਆਤੀ ਸਟੇਟ ਸ਼ਾਮਲ ਹੈ ਅਤੇ ਸਵੀਕਾਰਯੋਗ ਸਟੇਟਾਂ ਦਾ ਕੋਈ ਵੀ ਸਮੂਹ ਘੱਟੋ-ਘੱਟ DFA ਵਿੱਚ ਇੱਕ ਸਵੀਕਾਰਯੋਗ ਸਟੇਟ ਹੈ।


The program checks the input for validity.

ਪ੍ਰੋਗਰਾਮ ਇਨਪੁਟ ਦੀ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।


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

ਸੱਜੇ ਪਾਸੇ ਦਾ ਇੱਕ ਗੈਰ-ਟਰਮੀਨਲ ਸੰਬੰਧਿਤ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਕੇ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ।


The function match takes a symbol as an argument.

ਫੰਕਸ਼ਨ ਮੈਚ ਇੱਕ ਪ੍ਰਤੀਕ ਨੂੰ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਲੈਂਦਾ ਹੈ।


Table-driven LL(1) parsing encodes the selection of productions into a table.

ਟੇਬਲ-ਡ੍ਰਿਵਨ LL(1) ਪਾਰਸਿੰਗ ਉਤਪਾਦਨਾਂ ਦੀ ਚੋਣ ਨੂੰ ਇੱਕ ਟੇਬਲ ਵਿੱਚ ਏਨਕੋਡ ਕਰਦਾ ਹੈ।


The stack contains the part of the current derivation that has not yet been matched to the input.

ਸਟੈਕ ਵਿੱਚ ਮੌਜੂਦਾ ਡੈਰੀਵੇਸ਼ਨ ਦਾ ਉਹ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ ਜੋ ਅਜੇ ਇਨਪੁਟ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ।


Conflicts may be caused by ambiguous grammars.

ਵਿਵਾਦ ਅਸਪਸ਼ਟ ਵਿਆਕਰਣਾਂ ਕਾਰਨ ਹੋ ਸਕਦੇ ਹਨ।


We will look at elimination of left-recursion and at left factorisation.

ਅਸੀਂ ਖੱਬੇ-ਰਿਕਰਸ਼ਨ ਨੂੰ ਖਤਮ ਕਰਨ ਅਤੇ ਖੱਬੇ ਫੈਕਟਰਾਈਜ਼ੇਸ਼ਨ 'ਤੇ ਨਜ਼ਰ ਮਾਰਾਂਗੇ।


The unambiguous expression grammar is not LL(1).

ਅਸਪਸ਼ਟ ਸਮੀਕਰਨ ਵਿਆਕਰਣ LL(1) ਨਹੀਂ ਹੈ।


We must avoid left-recursion in the grammar.

ਸਾਨੂੰ ਵਿਆਕਰਣ ਵਿੱਚ ਖੱਬੇ-ਰਿਕਰਸ਼ਨ ਤੋਂ ਬਚਣਾ ਚਾਹੀਦਾ ਹੈ।


ਨਤੀਜੇ ਵਜੋਂ ਵਿਆਕਰਣ ਹੁਣ LL(1) ਹੈ।


Indirect left-recursion can have several faces.

ਅਸਿੱਧੇ ਖੱਬੇ-ਰਿਕਰਸ਼ਨ ਦੇ ਕਈ ਰੂਪ ਹੋ ਸਕਦੇ ਹਨ।


If two productions for the same nonterminal begin with the same sequence of symbols, they obviously have overlapping FIRST sets.

ਜੇਕਰ ਇੱਕੋ ਗੈਰ-ਟਰਮੀਨਲ ਲਈ ਦੋ ਉਤਪਾਦਨ ਇੱਕੋ ਜਿਹੇ ਪ੍ਰਤੀਕਾਂ ਦੇ ਕ੍ਰਮ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਵਿੱਚ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਓਵਰਲੈਪਿੰਗ FIRST ਸੈੱਟ ਹੁੰਦੇ ਹਨ।


The grammar is ambiguous and ambiguous grammars can not be LL(1).

ਵਿਆਕਰਣ ਅਸਪਸ਼ਟ ਹੈ ਅਤੇ ਅਸਪਸ਼ਟ ਵਿਆਕਰਣ LL(1) ਨਹੀਂ ਹੋ ਸਕਦੇ।


ਅਸਪਸ਼ਟਤਾ ਨੂੰ ਖਤਮ ਕਰੋ।


LR parsers accept a much larger class of grammars than LL(1) parsing.

LR ਪਾਰਸਰ LL(1) ਪਾਰਸਿੰਗ ਨਾਲੋਂ ਵਿਆਕਰਣਾਂ ਦੀ ਇੱਕ ਵੱਡੀ ਸ਼੍ਰੇਣੀ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ।


LR parsers are table-driven bottom-up parsers.

LR ਪਾਰਸਰ ਟੇਬਲ-ਡ੍ਰਿਵਨ ਬੌਟਮ-ਅੱਪ ਪਾਰਸਰ ਹਨ।


The stack holds the right-hand-side symbols.

ਸਟੈਕ ਸੱਜੇ-ਹੱਥ ਵਾਲੇ ਪ੍ਰਤੀਕਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ।


If the input text does not conform to the grammar, there will be an error.

ਜੇਕਰ ਇਨਪੁਟ ਟੈਕਸਟ ਵਿਆਕਰਣ ਦੇ ਅਨੁਕੂਲ ਨਹੀਂ ਹੈ, ਤਾਂ ਇੱਕ ਗਲਤੀ ਹੋਵੇਗੀ।


ਅਸੀਂ ਇੱਕ DFA ਬਣਾਉਂਦੇ ਹਾਂ।


The algorithm for parsing a string using the table is shown.

ਟੇਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਤਰ ਨੂੰ ਪਾਰਸ ਕਰਨ ਦਾ ਐਲਗੋਰਿਦਮ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।


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

ਜਿੱਥੇ φ ਖਾਲੀ ਭਾਸ਼ਾ ਲਈ ਨਿਯਮਤ ਸਮੀਕਰਨ ਹੈ (ਅਭਿਆਸ 2.10 ਵੇਖੋ)।


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

a) ਗੈਰ-ਖਾਲੀ ਦੀ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਪੂਰਾ ਕਰੋ, ਉਪਰੋਕਤ ਨਿਯਮਾਂ ਵਿੱਚ “...” ਦੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ε ਅਤੇ s|t ਦੇ ਨਿਯਮਾਂ ਵਿੱਚ ਦਿਖਾਈਆਂ ਗਈਆਂ ਸਮਾਨ ਸਮੀਕਰਨਾਂ ਨਾਲ ਬਦਲ ਕੇ।


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

b) ਇਸ ਪਰਿਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਗੈਰ-ਖਾਲੀ(a * b * ) ਨੂੰ ਲੱਭਣ ਲਈ ਕਰੋ।


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

ਜੇਕਰ 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) ਪ੍ਰੀਫਿਕਸ ਦੀ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਪੂਰਾ ਕਰੋ, ਉਪਰੋਕਤ ਨਿਯਮਾਂ ਵਿੱਚ “...” ਦੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ε, a ਅਤੇ s|t ਦੇ ਨਿਯਮਾਂ ਵਿੱਚ ਦਿਖਾਈਆਂ ਗਈਆਂ ਸਮਾਨ ਸਮੀਕਰਨਾਂ ਨਾਲ ਬਦਲ ਕੇ।


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

b) ਪ੍ਰੀਫਿਕਸ(ab * c) ਲੱਭਣ ਲਈ ਇਸ ਪਰਿਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰੋ।


Where lexical analysis splits the input into tokens, the purpose of syntax analysis (also known as parsing) is to recombine these tokens.

ਜਿੱਥੇ ਸ਼ਬਦਕੋਸ਼ ਵਿਸ਼ਲੇਸ਼ਣ ਇਨਪੁਟ ਨੂੰ ਟੋਕਨਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ, ਸਿੰਟੈਕਸ ਵਿਸ਼ਲੇਸ਼ਣ (ਜਿਸਨੂੰ ਪਾਰਸਿੰਗ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਦਾ ਉਦੇਸ਼ ਇਹਨਾਂ ਟੋਕਨਾਂ ਨੂੰ ਮੁੜ ਜੋੜਨਾ ਹੈ।


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.

ਇਸ ਬਿੰਦੂ 'ਤੇ, ਇਹ ਇਨਪੁਟ ਪੜ੍ਹਨਾ ਬੰਦ ਕਰ ਸਕਦਾ ਹੈ।


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

ਬਾਅਦ ਵਾਲੇ ਪਹੁੰਚ ਦਾ ਉਦੇਸ਼ ਹੋਰ ਸ਼ਬਦ-ਕੋਸ਼ ਗਲਤੀਆਂ ਲੱਭਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ ਹੈ।


Some of these subsequent errors may, however, not be real errors.

ਹਾਲਾਂਕਿ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਕੁਝ ਬਾਅਦ ਦੀਆਂ ਗਲਤੀਆਂ ਅਸਲ ਗਲਤੀਆਂ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ।


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.

ਇੱਕ ਲੇਕਸਰ ਜਨਰੇਟਰ ਆਮ ਤੌਰ 'ਤੇ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਲਈ ਇੱਕ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ।


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

ਉਦਾਹਰਨ ਲਈ, ਇਨਪੁਟ ਵਿੱਚ ਗੁਣਾ ਦੇ ਪ੍ਰਤੀਕ ਨਾਲ ਮੇਲ ਕਰਨ ਦਾ ਇਰਾਦਾ ਰੱਖਣ ਵਾਲੇ * ਨੂੰ ਦੁਹਰਾਓ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤੇ ਗਏ * ਤੋਂ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ‘*‘.


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.

ਐਕਸ਼ਨ ਦੱਸਦਾ ਹੈ ਕਿ ਖਪਤਕਾਰ ਨੂੰ ਕੀ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


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

ਆਮ ਤੌਰ 'ਤੇ, ਲੇਕਸਰ ਜਨਰੇਟਰ ਨੂੰ ਵ੍ਹਾਈਟ-ਸਪੇਸ ਅਤੇ ਟਿੱਪਣੀਆਂ ਨੂੰ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


An action can be more than just returning a token.

ਇੱਕ ਐਕਸ਼ਨ ਸਿਰਫ਼ ਇੱਕ ਟੋਕਨ ਵਾਪਸ ਕਰਨ ਤੋਂ ਵੱਧ ਹੋ ਸਕਦਾ ਹੈ।


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

ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਕਿਸੇ ਭਾਸ਼ਾ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਕੀਵਰਡ ਹਨ, ਤਾਂ ਇੱਕ DFA ਜੋ ਇਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪਛਾਣਦਾ ਹੈ, ਕਾਫ਼ੀ ਵੱਡਾ ਹੋ ਸਕਦਾ ਹੈ।


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

ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਕੀਵਰਡਸ ਨੂੰ ਲੇਕਸਰ ਪਰਿਭਾਸ਼ਾ ਵਿੱਚ ਵੱਖਰੇ ਨਿਯਮਤ ਸਮੀਕਰਨਾਂ ਵਜੋਂ ਵਰਣਿਤ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਸ ਦੀ ਬਜਾਏ ਪਛਾਣਕਰਤਾ ਟੋਕਨ ਦੇ ਵਿਸ਼ੇਸ਼ ਮਾਮਲਿਆਂ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।


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

ਗੈਰ-ਮਾਮੂਲੀ ਲੇਕਸਰ ਐਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਹੋਰ ਵਰਤੋਂ ਨੇਸਟਡ ਟਿੱਪਣੀਆਂ ਲਈ ਹੈ।


In principle, a regular expression cannot recognise arbitrarily nested comments.

ਸਿਧਾਂਤ ਵਿੱਚ, ਇੱਕ ਨਿਯਮਤ ਸਮੀਕਰਨ ਮਨਮਾਨੇ ਢੰਗ ਨਾਲ ਨੇਸਟਡ ਟਿੱਪਣੀਆਂ ਨੂੰ ਪਛਾਣ ਨਹੀਂ ਸਕਦਾ।


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.

ਇਸ ਲਈ, ਇੱਕ ਖਾਸ ਤਰਜੀਹ ਪੱਧਰ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਗੈਰ-ਟਰਮੀਨਲ ਲਈ ਉਤਪਾਦਨ ਸਿਰਫ਼ ਉਹਨਾਂ ਗੈਰ-ਟਰਮੀਨਲਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਉਸੇ ਜਾਂ ਉੱਚ ਤਰਜੀਹ ਪੱਧਰਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ।


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 for 2+3*4 using this grammar.

ਚਿੱਤਰ 3.12 ਇਸ ਵਿਆਕਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ 2+3*4 ਲਈ ਸਿੰਟੈਕਸ ਟ੍ਰੀ ਦਿਖਾਉਂਦਾ ਹੈ।


Most of the potential ambiguity in grammars for programming languages comes from expression syntax.

ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਲਈ ਵਿਆਕਰਣ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵੀ ਅਸਪਸ਼ਟਤਾ ਸਮੀਕਰਨਾਂ ਦੇ ਵਾਕ-ਵਿਗਿਆਨ ਤੋਂ ਆਉਂਦੀ ਹੈ।


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

ਅਸਪਸ਼ਟਤਾ ਦੀ ਇੱਕ ਹੋਰ ਕਲਾਸੀਕਲ ਉਦਾਹਰਣ “ਡੈਂਗਲਿੰਗ-ਐਲਸ” ਸਮੱਸਿਆ ਹੈ।


Imperative languages like Pascal or C often let the else-part of a conditional be optional.

ਪੈਸਕਲ ਜਾਂ ਸੀ ਵਰਗੀਆਂ ਜ਼ਰੂਰੀ ਭਾਸ਼ਾਵਾਂ ਅਕਸਰ ਇੱਕ ਸ਼ਰਤੀਆ ਦੇ ਐਲਸ-ਭਾਗ ਨੂੰ ਵਿਕਲਪਿਕ ਹੋਣ ਦਿੰਦੀਆਂ ਹਨ।


The problem is that it is not clear how to parse, for example, if p then if q then s1 else s2.

ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਇਹ ਸਪੱਸ਼ਟ ਨਹੀਂ ਹੈ ਕਿ ਕਿਵੇਂ ਪਾਰਸ ਕਰਨਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ p ਤਾਂ ਜੇਕਰ q ਤਾਂ s1 ਨਹੀਂ ਤਾਂ s2।


According to the grammar, the else can equally well match either if.

ਵਿਆਕਰਣ ਦੇ ਅਨੁਸਾਰ, ਐਲਸ ਬਰਾਬਰ ਹੀ ਜੇਕਰ ਨਾਲ ਮੇਲ ਕਰ ਸਕਦਾ ਹੈ।


The usual convention is that an else matches the closest not previously matched if.

ਆਮ ਰਿਵਾਜ ਇਹ ਹੈ ਕਿ ਇੱਕ ਐਲਸ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਪਹਿਲਾਂ ਮੇਲ ਨਾ ਕੀਤੇ ਗਏ ਜੇਕਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।


How do we make this clear in the grammar?

ਅਸੀਂ ਇਸਨੂੰ ਵਿਆਕਰਣ ਵਿੱਚ ਕਿਵੇਂ ਸਪੱਸ਼ਟ ਕਰੀਏ?


We can treat if, then and else as a kind of right-associative operators.

ਅਸੀਂ ਜੇਕਰ, ਫਿਰ ਅਤੇ ਐਲਸ ਨੂੰ ਇੱਕ ਕਿਸਮ ਦੇ ਸੱਜੇ-ਸੰਬੰਧਿਤ ਓਪਰੇਟਰਾਂ ਵਜੋਂ ਵਰਤ ਸਕਦੇ ਹਾਂ।


However, the grammar transformations shown in section 3.4 can not directly be applied to grammar 3.3.

ਹਾਲਾਂਕਿ, ਭਾਗ 3.4 ਵਿੱਚ ਦਿਖਾਈ ਗਈ ਵਿਆਕਰਣ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਵਿਆਕਰਣ 3.3 'ਤੇ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


Instead we use the following observation: When an if and an else match, all ifs that occur between these must have matching elses.

ਇਸ ਦੀ ਬਜਾਏ ਅਸੀਂ ਹੇਠ ਲਿਖੀ ਗੱਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ: ਜਦੋਂ ਇੱਕ ਜੇਕਰ ਅਤੇ ਇੱਕ ਐਲਸ ਮੇਲ ਖਾਂਦੇ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਦੇ ਵਿਚਕਾਰ ਆਉਣ ਵਾਲੇ ਸਾਰੇ ਜੇਕਰ ਵਿੱਚ ਮੇਲ ਖਾਂਦੇ ਐਲਸ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।


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. with else-part) conditionals and one for unmatched (i.e. without else-part) conditionals.

ਇਸ ਲਈ, ਅਸੀਂ ਦੋ ਗੈਰ-ਟਰਮੀਨਲ ਬਣਾਉਂਦੇ ਹਾਂ: ਇੱਕ ਮੇਲ ਖਾਂਦੇ (ਭਾਵ ਐਲਸ-ਭਾਗ ਦੇ ਨਾਲ) ਸ਼ਰਤੀਆ ਲਈ ਅਤੇ ਇੱਕ ਬੇਮੇਲ (ਭਾਵ ਐਲਸ-ਭਾਗ ਤੋਂ ਬਿਨਾਂ) ਸ਼ਰਤੀਆ ਲਈ।


The syntax analysis phase of a compiler will take a string of tokens produced by the lexer.

ਇੱਕ ਕੰਪਾਈਲਰ ਦਾ ਸਿੰਟੈਕਸ ਵਿਸ਼ਲੇਸ਼ਣ ਪੜਾਅ ਲੇਕਸਰ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਗਏ ਟੋਕਨਾਂ ਦੀ ਇੱਕ ਸਤਰ ਲਵੇਗਾ।


This can be done by guessing derivations until the right one is found, but random guessing is hardly an effective method.

ਇਹ ਡੈਰੀਵੇਸ਼ਨ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਕੇ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਸਹੀ ਇੱਕ ਨਹੀਂ ਮਿਲ ਜਾਂਦਾ, ਪਰ ਬੇਤਰਤੀਬ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ ਸ਼ਾਇਦ ਹੀ ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕਾ ਹੈ।


Predictive parsers always build the syntax tree from the root down to the leaves.

ਪੂਰਵ-ਅਨੁਮਾਨਕ ਪਾਰਸਰ ਹਮੇਸ਼ਾ ਸਿੰਟੈਕਸ ਟ੍ਰੀ ਨੂੰ ਜੜ੍ਹ ਤੋਂ ਪੱਤਿਆਂ ਤੱਕ ਬਣਾਉਂਦੇ ਹਨ।


Other parsers go the other way: They search for parts of the input string that matches right-hand sides of productions.

ਹੋਰ ਪਾਰਸਰ ਦੂਜੇ ਤਰੀਕੇ ਨਾਲ ਜਾਂਦੇ ਹਨ: ਉਹ ਇਨਪੁਟ ਸਤਰ ਦੇ ਉਹਨਾਂ ਹਿੱਸਿਆਂ ਦੀ ਭਾਲ ਕਰਦੇ ਹਨ ਜੋ ਉਤਪਾਦਨ ਦੇ ਸੱਜੇ ਪਾਸੇ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ।


We will in the next sections first look at predictive parsing and later at a bottom-up parsing method called SLR parsing.

ਅਸੀਂ ਅਗਲੇ ਭਾਗਾਂ ਵਿੱਚ ਪਹਿਲਾਂ ਪੂਰਵ-ਅਨੁਮਾਨਕ ਪਾਰਸਿੰਗ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਇੱਕ ਹੇਠਾਂ-ਤੋਂ-ਉੱਪਰ ਪਾਰਸਿੰਗ ਵਿਧੀ ਜਿਸਨੂੰ SLR ਪਾਰਸਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, 'ਤੇ ਇੱਕ ਨਜ਼ਰ ਮਾਰਾਂਗੇ।


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.

ਸਾਨੂੰ ਹੁਣ ਇਸ 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.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.

NFA ਸਟੇਟਾਂ ਦੇ ਸਮੂਹ ਜੋ ਹਰੇਕ DFA ਸਟੇਟ ਨੂੰ ਬਣਾਉਂਦੇ ਹਨ, ਚਿੱਤਰ 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.

reduce ਅਤੇ accept ਐਕਸ਼ਨ ਜੋੜਨ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਹਰੇਕ ਗੈਰ-ਟਰਮੀਨਲ ਲਈ FOLLOW ਸੈੱਟਾਂ ਦੀ ਗਣਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਜਿਵੇਂ ਕਿ ਭਾਗ 3.10 ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ।


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

ਫਿਰ ਅਸੀਂ ਹੇਠਲੇ ਨਿਯਮ ਦੁਆਰਾ reduce ਐਕਸ਼ਨ ਜੋੜਦੇ ਹਾਂ: ਜੇਕਰ ਇੱਕ DFA ਸਟੇਟ ਵਿੱਚ ਇੱਕ ਉਤਪਾਦਨp:N→α ਲਈ ਸਵੀਕਾਰ ਕਰਨ ਵਾਲੀ NFA ਸਟੇਟ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਾਰੇ ਪ੍ਰਤੀਕਾਂ ਵਿੱਚ reduce pas ਐਕਸ਼ਨ ਜੋੜਦੇ ਹਾਂ।


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

ਉਤਪਾਦਨ 0 (ਵਾਧੂ ਸ਼ੁਰੂਆਤੀ ਉਤਪਾਦਨ ਜੋ NFA ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਜੋੜਿਆ ਗਿਆ ਸੀ) 'ਤੇ ਕਮੀ ਨੂੰ accept ਵਜੋਂ ਲਿਖਿਆ ਗਿਆ ਹੈ।


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

ਚਿੱਤਰ 3.28 ਵਿੱਚ, ਸਟੇਟ 0 ਵਿੱਚ NFA ਸਟੇਟ I ਹੈ, ਜੋ ਉਤਪਾਦਨ 3 ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।


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

ਇਸ ਲਈ, ਅਸੀਂ ਪ੍ਰਤੀਕਾਂ c ਅਤੇ $ 'ਤੇ r3 ਨੂੰ ਐਕਸ਼ਨ ਵਜੋਂ ਜੋੜਦੇ ਹਾਂ (ਕਿਉਂਕਿ ਇਹ FOLLOW(R) ਵਿੱਚ ਹਨ)।


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

ਸਟੇਟ 1 ਵਿੱਚ NFA ਸਟੇਟ B ਹੈ, ਜੋ ਉਤਪਾਦਨ 0 ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।


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

ਅਸੀਂ ਇਸਨੂੰ ਪ੍ਰਤੀਕ $ (FOLLOW(T ′ )) 'ਤੇ ਜੋੜਦੇ ਹਾਂ।


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

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, ਇਸਨੂੰ accept (ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ “a”) ਵਜੋਂ ਲਿਖਿਆ ਗਿਆ ਹੈ।


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

ਇਸੇ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਸਟੇਟ 3, 4, 6 ਅਤੇ 7 ਵਿੱਚ reduce ਐਕਸ਼ਨ ਜੋੜਦੇ ਹਾਂ।


Figure 3.29 summarises the SLR construction.

ਚਿੱਤਰ 3.29 SLR ਉਸਾਰੀ ਦਾ ਸਾਰ ਦਿੰਦਾ ਹੈ।


The compiler checks for type errors during the compilation process.

ਕੰਪਾਈਲਰ ਕੰਪਾਈਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਟਾਈਪ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।


Variables and functions are bound to their types in symbol tables.

ਵੇਰੀਏਬਲ ਅਤੇ ਫੰਕਸ਼ਨ ਪ੍ਰਤੀਕ ਟੇਬਲਾਂ ਵਿੱਚ ਉਹਨਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਨਾਲ ਬੰਨ੍ਹੇ ਹੁੰਦੇ ਹਨ।


Type checking ensures that the program follows the rules of the language.

ਟਾਈਪ ਜਾਂਚ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਭਾਸ਼ਾ ਦੇ ਨਿਯਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ।


The abstract syntax tree is used to represent the structure of the code.

ਕੋਡ ਦੀ ਬਣਤਰ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਐਬਸਟਰੈਕਟ ਸਿੰਟੈਕਸ ਟ੍ਰੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


A function declaration explicitly states the types of its arguments.

ਇੱਕ ਫੰਕਸ਼ਨ ਘੋਸ਼ਣਾ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਸਦੇ ਦਲੀਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ ਨੂੰ ਦੱਸਦੀ ਹੈ।


The compiler generates intermediate code as a stepping stone.

ਕੰਪਾਈਲਰ ਇੱਕ ਪੌੜੀ ਦੇ ਪੱਥਰ ਵਜੋਂ ਵਿਚਕਾਰਲਾ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।


The program is checked for type correctness.

ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਿਸਮ ਦੀ ਸ਼ੁੱਧਤਾ ਲਈ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The type checker reports any type errors found.

ਟਾਈਪ ਚੈਕਰ ਕਿਸੇ ਵੀ ਟਾਈਪ ਗਲਤੀਆਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਜੋ ਮਿਲੀਆਂ ਹਨ।


The symbol table stores information about variables and functions.

ਪ੍ਰਤੀਕ ਟੇਬਲ ਵੇਰੀਏਬਲ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕਰਦਾ ਹੈ।


The compiler translates high-level code into machine code.

ਕੰਪਾਈਲਰ ਉੱਚ-ਪੱਧਰੀ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ।


ਇਹ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਹੈ।


ਕੀ ਤੁਸੀਂ ਇਸ ਵਿੱਚ ਮੇਰੀ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ?


ਮੈਂ ਪੰਜਾਬੀ ਸਿੱਖ ਰਿਹਾ ਹਾਂ।


ਅੱਜ ਮੌਸਮ ਵਧੀਆ ਹੈ।


ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?


ਮੈਨੂੰ ਬਾਜ਼ਾਰ ਜਾਣਾ ਹੈ।


The function takes two integer arguments and returns an integer.

ਫੰਕਸ਼ਨ ਦੋ ਪੂਰਨ ਅੰਕ ਦਲੀਲਾਂ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰਦਾ ਹੈ।


The compiler optimizes the code for better performance.

ਕੰਪਾਈਲਰ ਬਿਹਤਰ ਪ੍ਰਦਰਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ।


The intermediate code is platform-independent.

ਵਿਚਕਾਰਲਾ ਕੋਡ ਪਲੇਟਫਾਰਮ-ਨਿਰਭਰ ਨਹੀਂ ਹੈ।


Type checking is a crucial step in the compilation process.

ਟਾਈਪ ਜਾਂਚ ਕੰਪਾਈਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ।


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.

ਕੁਝ ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਇੰਟਰਪ੍ਰੈਟਰ ਦੁਆਰਾ ਸਾਈਡ ਇਫੈਕਟਸ ਦੇ ਤੌਰ 'ਤੇ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।


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.

ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਕਿਸੇ ਵੀ ਭਾਸ਼ਾ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


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

ਅਸੀਂ ਵਿਆਖਿਆ ਦੇ ਸਿਧਾਂਤਾਂ ਨੂੰ ਦਿਖਾਉਣ ਲਈ ਇੱਕ ਛੋਟੀ ਜਿਹੀ ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।


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

ਭਾਸ਼ਾ ਰਿਕਰਸਿਵ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੇ ਨਾਲ ਇੱਕ ਪਹਿਲੇ-ਆਰਡਰ ਦੀ ਕਾਰਜਸ਼ੀਲ ਭਾਸ਼ਾ ਹੈ।


ਸਿੰਟੈਕਸ ਵਿਆਕਰਣ 5.1 ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।


In the example language, a program is a list of function declarations.

ਉਦਾਹਰਨ ਭਾਸ਼ਾ ਵਿੱਚ, ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਫੰਕਸ਼ਨ ਘੋਸ਼ਣਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ।


The body of a function is an expression.

ਇੱਕ ਫੰਕਸ਼ਨ ਦਾ ਸਰੀਰ ਇੱਕ ਸਮੀਕਰਨ ਹੈ।


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 languages are, as regular languages, closed under union.

ਸੰਦਰਭ-ਮੁਕਤ ਭਾਸ਼ਾਵਾਂ, ਨਿਯਮਤ ਭਾਸ਼ਾਵਾਂ ਵਾਂਗ, ਯੂਨੀਅਨ ਦੇ ਅਧੀਨ ਬੰਦ ਹੁੰਦੀਆਂ ਹਨ।


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

ਸੰਦਰਭ-ਮੁਕਤ ਵਿਆਕਰਣਾਂ ਨੂੰ ਪਹਿਲੀ ਵਾਰ ਕੁਦਰਤੀ ਭਾਸ਼ਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਇੱਕ ਸੰਕੇਤ ਵਜੋਂ ਪ੍ਰਸਤਾਵਿਤ ਕੀਤਾ ਗਿਆ ਸੀ।


In context-free grammars, derivation of a nonterminal is independent of the context in which the terminal occurs.

ਸੰਦਰਭ-ਮੁਕਤ ਵਿਆਕਰਣਾਂ ਵਿੱਚ, ਇੱਕ ਗੈਰ-ਟਰਮੀਨਲ ਦਾ ਡੈਰੀਵੇਸ਼ਨ ਉਸ ਸੰਦਰਭ ਤੋਂ ਸੁਤੰਤਰ ਹੁੰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਟਰਮੀਨਲ ਹੁੰਦਾ ਹੈ।


Context-free grammars are actually too weak to describe natural languages, but were adopted for defining the Algol60 programming language.

ਸੰਦਰਭ-ਮੁਕਤ ਵਿਆਕਰਣ ਅਸਲ ਵਿੱਚ ਕੁਦਰਤੀ ਭਾਸ਼ਾਵਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਲਈ ਬਹੁਤ ਕਮਜ਼ੋਰ ਹਨ, ਪਰ ਅਲਗੋਲ60 ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਅਪਣਾਏ ਗਏ ਸਨ।


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

ਜ਼ਿਆਦਾਤਰ ਪਾਰਸਰ ਜਨਰੇਟਰ LALR(1) ਪਾਰਸਿੰਗ 'ਤੇ ਅਧਾਰਤ ਹਨ, ਪਰ ਕੁਝ LL(1) ਪਾਰਸਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।


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

“ਡਰੈਗਨ ਬੁੱਕ” ਮੌਜੂਦਾ ਕਿਤਾਬ ਨਾਲੋਂ ਪਾਰਸਿੰਗ ਵਿਧੀਆਂ ਬਾਰੇ ਵਧੇਰੇ ਦੱਸਦੀ ਹੈ।


Draw a third, different syntax tree for aabbbcc using the same grammar 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: a) All sequences of as and bs that contain the same number of as and bs (in any order).

ਹੇਠ ਲਿਖੀਆਂ ਹਰੇਕ ਭਾਸ਼ਾ ਲਈ ਵਿਆਕਰਣ ਲਿਖੋ: a) a ਅਤੇ b ਦੇ ਸਾਰੇ ਕ੍ਰਮ ਜਿਸ ਵਿੱਚ a ਅਤੇ b ਦੀ ਗਿਣਤੀ ਇੱਕੋ ਜਿਹੀ ਹੋਵੇ (ਕਿਸੇ ਵੀ ਕ੍ਰਮ ਵਿੱਚ)।


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

ਇੱਕ ਅਜਿਹੀ ਸਤਰ ਲੱਭ ਕੇ ਦਿਖਾਓ ਜਿਸ ਵਿੱਚ ਦੋ ਵੱਖ-ਵੱਖ ਸਿੰਟੈਕਸ ਟ੍ਰੀ ਹਨ, ਕਿ ਵਿਆਕਰਣ ਅਸਪਸ਼ਟ ਹੈ।


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

ਕੁਝ ਭਾਸ਼ਾਵਾਂ (ਜਿਵੇਂ ਕਿ ਪਾਸਕਲ) ਵਿੱਚ, ਇੱਕੋ ਸਕੋਪ ਵਿੱਚ ਇੱਕ ਵੇਰੀਏਬਲ ਅਤੇ ਇੱਕ ਫੰਕਸ਼ਨ ਦਾ ਇੱਕੋ ਨਾਮ ਹੋ ਸਕਦਾ ਹੈ।


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

ਅਜਿਹੇ ਹਰੇਕ ਨਾਮ ਵਾਲੇ ਆਬਜੈਕਟ ਦੀ ਇੱਕ ਘੋਸ਼ਣਾ ਹੋਵੇਗੀ, ਜਿੱਥੇ ਨਾਮ ਨੂੰ ਆਬਜੈਕਟ ਲਈ ਸਮਾਨਾਰਥੀ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।


ਇਸਨੂੰ ਬਾਈਡਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


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

ਹਰੇਕ ਨਾਮ ਦੀਆਂ ਕਈ ਵਰਤੋਂ ਵੀ ਹੋਣਗੀਆਂ, ਜਿੱਥੇ ਨਾਮ ਦੀ ਵਰਤੋਂ ਉਸ ਆਬਜੈਕਟ ਦੇ ਹਵਾਲੇ ਵਜੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸ ਨਾਲ ਇਹ ਬੰਨ੍ਹਿਆ ਹੋਇਆ ਹੈ।


Often, the declaration of a name has a limited scope: a portion of the program where the name will be visible.

ਅਕਸਰ, ਇੱਕ ਨਾਮ ਦੀ ਘੋਸ਼ਣਾ ਦਾ ਇੱਕ ਸੀਮਤ ਸਕੋਪ ਹੁੰਦਾ ਹੈ: ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਹਿੱਸਾ ਜਿੱਥੇ ਨਾਮ ਦਿਖਾਈ ਦੇਵੇਗਾ।


Such declarations are called local declarations, whereas a declaration that makes the declared name visible in the entire program is called global.

ਅਜਿਹੀਆਂ ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਸਥਾਨਕ ਘੋਸ਼ਣਾਵਾਂ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਇੱਕ ਘੋਸ਼ਣਾ ਜੋ ਘੋਸ਼ਿਤ ਨਾਮ ਨੂੰ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ, ਨੂੰ ਗਲੋਬਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


It may happen that the same name is declared in several nested scopes.

ਅਜਿਹਾ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਇੱਕੋ ਨਾਮ ਕਈ ਨੇਸਟਡ ਸਕੋਪ ਵਿੱਚ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੋਵੇ।


A compiler will need to keep track of names and the objects these are bound to, so that any use of a name will be attributed correctly to its declaration.

ਇੱਕ ਕੰਪਾਈਲਰ ਨੂੰ ਨਾਵਾਂ ਅਤੇ ਉਹਨਾਂ ਵਸਤੂਆਂ ਦਾ ਧਿਆਨ ਰੱਖਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ ਜਿਨ੍ਹਾਂ ਨਾਲ ਇਹ ਬੰਨ੍ਹੇ ਹੋਏ ਹਨ, ਤਾਂ ਜੋ ਕਿਸੇ ਨਾਮ ਦੀ ਵਰਤੋਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਇਸਦੀ ਘੋਸ਼ਣਾ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕੇ।


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.

ਜੇਕਰ ਇੱਕ ਸਾਂਝੀ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਹਰ ਭਾਸ਼ਾ ਲਈ ਇੱਕ ਫਰੰਟ-ਐਂਡ ਅਤੇ ਹਰੇਕ ਮਸ਼ੀਨ ਲਈ ਇੱਕ ਬੈਕ-ਐਂਡ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


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.

ਵਿਚਕਾਰਲੇ ਰੂਪ ਦੀ ਵਿਆਖਿਆ ਕਰਨਾ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ ਸਿੱਧੇ ਅਨੁਵਾਦ ਕੀਤੇ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਨਾਲੋਂ ਬਹੁਤ ਹੌਲੀ ਹੋਵੇਗਾ।


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

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਠੀਕ ਪਹਿਲਾਂ ਜਾਂ ਦੌਰਾਨ ਵਿਚਕਾਰਲੇ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਕੇ ਕੁਝ ਗਤੀ ਜੁਰਮਾਨੇ ਨੂੰ ਖਤਮ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


An intermediate language should, ideally, have the following properties: It should be easy to translate from a high-level language to the intermediate language.

ਇੱਕ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ, ਆਦਰਸ਼ਕ ਤੌਰ 'ਤੇ, ਹੇਠ ਲਿਖੇ ਗੁਣ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ: ਇੱਕ ਉੱਚ-ਪੱਧਰੀ ਭਾਸ਼ਾ ਤੋਂ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨਾ ਆਸਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


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

ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਤੋਂ ਮਸ਼ੀਨ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਨਾ ਆਸਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


The intermediate format should be suitable for optimisations.

ਵਿਚਕਾਰਲਾ ਫਾਰਮੈਟ ਅਨੁਕੂਲਤਾ ਲਈ ਢੁਕਵਾਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


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

ਇੱਕ ਹੱਲ ਜੋ ਅਨੁਵਾਦ ਦੇ ਬੋਝ ਨੂੰ ਘਟਾ ਸਕਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਦੂਜੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਨਹੀਂ ਕਰਦਾ, ਦੋ ਵਿਚਕਾਰਲੇ ਪੱਧਰਾਂ ਦਾ ਹੋਣਾ ਹੈ।


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

ਜਦੋਂ ਵਿਚਕਾਰਲਾ ਫਾਰਮੈਟ ਬਹੁਤ ਸਾਰੇ ਕੰਪਾਈਲਰਾਂ ਵਿੱਚ ਸਾਂਝਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਵਿਚਕਾਰਲੇ ਫਾਰਮੈਟ 'ਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਅਨੁਕੂਲਤਾ ਕਰਨਾ ਸਮਝਦਾਰੀ ਹੁੰਦੀ ਹੈ।


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

ਇੱਕ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਦੀ ਚੋਣ ਕਰਦੇ ਸਮੇਂ ਵਿਚਾਰਨ ਵਾਲੀ ਇੱਕ ਹੋਰ ਗੱਲ ਹੈ “ਦਾਣੇਦਾਰੀ”।


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

ਕੀ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਵਿੱਚ ਇੱਕ ਓਪਰੇਸ਼ਨ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਕੰਮ ਜਾਂ ਥੋੜ੍ਹੀ ਜਿਹੀ ਮਾਤਰਾ ਵਿੱਚ ਕੰਮ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ?


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

ਇਹਨਾਂ ਪਹੁੰਚਾਂ ਵਿੱਚੋਂ ਪਹਿਲਾ ਅਕਸਰ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


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

ਵਿਰੋਧੀ ਪਹੁੰਚ ਹਰੇਕ ਵਿਚਕਾਰਲੇ-ਕੋਡ ਓਪਰੇਸ਼ਨ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਛੋਟਾ ਹੋਣ ਦੇਣਾ ਹੈ।


When intermediate-code is translated to machine- code, the code generator can look for sequences that match machine-code operations.

ਜਦੋਂ ਵਿਚਕਾਰਲੇ-ਕੋਡ ਦਾ ਮਸ਼ੀਨ-ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਕੋਡ ਜਨਰੇਟਰ ਉਹਨਾਂ ਲੜੀਵਾਰਾਂ ਦੀ ਭਾਲ ਕਰ ਸਕਦਾ ਹੈ ਜੋ ਮਸ਼ੀਨ-ਕੋਡ ਓਪਰੇਸ਼ਨਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ।


ਅਸੀਂ ਇਸ 'ਤੇ ਅਧਿਆਇ 8 ਵਿੱਚ ਵਾਪਸ ਆਵਾਂਗੇ।


A label. This has no effect but serves only to mark the position in the program as a target for jumps.

ਇੱਕ ਲੇਬਲ। ਇਸਦਾ ਕੋਈ ਪ੍ਰਭਾਵ ਨਹੀਂ ਹੁੰਦਾ ਪਰ ਸਿਰਫ਼ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਸਥਿਤੀ ਨੂੰ ਜੰਪਾਂ ਲਈ ਇੱਕ ਟੀਚੇ ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕਰਨ ਦਾ ਕੰਮ ਕਰਦਾ ਹੈ।


An assignment of an atomic expression (constant or variable) to a variable.

ਇੱਕ ਪਰਮਾਣੂ ਸਮੀਕਰਨ (ਸਥਿਰ ਜਾਂ ਵੇਰੀਏਬਲ) ਦਾ ਇੱਕ ਵੇਰੀਏਬਲ ਨੂੰ ਅਸਾਈਨਮੈਂਟ।


The compiler typically has a large address space where it can allocate statically allocated objects.

ਕੰਪਾਈਲਰ ਕੋਲ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਵੱਡਾ ਐਡਰੈੱਸ ਸਪੇਸ ਹੁੰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਸਥਿਰ ਤੌਰ 'ਤੇ ਅਲਾਟ ਕੀਤੇ ਆਬਜੈਕਟਸ ਨੂੰ ਅਲਾਟ ਕਰ ਸਕਦਾ ਹੈ।


We will briefly discuss how such can be implemented.

ਅਸੀਂ ਛੇਤੀ ਹੀ ਇਸ ਬਾਰੇ ਚਰਚਾ ਕਰਾਂਗੇ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


Labels are stored in a symbol table that binds each to a corresponding label in the intermediate language.

ਲੇਬਲ ਇੱਕ ਪ੍ਰਤੀਕ ਟੇਬਲ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਜੋ ਹਰੇਕ ਨੂੰ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਵਿੱਚ ਇੱਕ ਸੰਬੰਧਿਤ ਲੇਬਲ ਨਾਲ ਜੋੜਦਾ ਹੈ।


A jump to a label will generate a GOTO statement to the corresponding intermediate-language label.

ਇੱਕ ਲੇਬਲ 'ਤੇ ਜੰਪ ਵਿਚਕਾਰਲੀ ਭਾਸ਼ਾ ਦੇ ਸੰਬੰਧਿਤ ਲੇਬਲ 'ਤੇ ਇੱਕ GOTO ਬਿਆਨ ਤਿਆਰ ਕਰੇਗਾ।


Unless labels are declared before use, an extra pass may be needed to build the symbol table before the actual translation.

ਜਦੋਂ ਤੱਕ ਵਰਤੋਂ ਤੋਂ ਪਹਿਲਾਂ ਲੇਬਲ ਦਾ ਐਲਾਨ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ, ਅਸਲ ਅਨੁਵਾਦ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਤੀਕ ਟੇਬਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਵਾਧੂ ਪਾਸ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ।


Alternatively, an intermediate-language label can be chosen and an entry in the symbol table be created at the first occurrence of the label even if it is in a jump rather than a declaration.

ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ, ਇੱਕ ਵਿਚਕਾਰਲੀ-ਭਾਸ਼ਾ ਦਾ ਲੇਬਲ ਚੁਣਿਆ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਲੇਬਲ ਦੀ ਪਹਿਲੀ ਘਟਨਾ 'ਤੇ ਪ੍ਰਤੀਕ ਟੇਬਲ ਵਿੱਚ ਇੱਕ ਐਂਟਰੀ ਬਣਾਈ ਜਾ ਸਕਦੀ ਹੈ ਭਾਵੇਂ ਇਹ ਘੋਸ਼ਣਾ ਦੀ ਬਜਾਏ ਇੱਕ ਜੰਪ ਵਿੱਚ ਹੋਵੇ।


Subsequent jumps or declarations of that label will use the intermediate-language label that was chosen at the first occurrence.

ਉਸ ਲੇਬਲ ਦੇ ਬਾਅਦ ਦੇ ਜੰਪ ਜਾਂ ਘੋਸ਼ਣਾਵਾਂ ਵਿਚਕਾਰਲੀ-ਭਾਸ਼ਾ ਦੇ ਲੇਬਲ ਦੀ ਵਰਤੋਂ ਕਰਨਗੀਆਂ ਜੋ ਪਹਿਲੀ ਘਟਨਾ 'ਤੇ ਚੁਣਿਆ ਗਿਆ ਸੀ।


By setting a mark in the symbol-table entry when the label is declared, it can be checked that all labels are declared exactly once.

ਜਦੋਂ ਲੇਬਲ ਦਾ ਐਲਾਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਪ੍ਰਤੀਕ-ਟੇਬਲ ਐਂਟਰੀ ਵਿੱਚ ਇੱਕ ਨਿਸ਼ਾਨ ਲਗਾ ਕੇ, ਇਹ ਜਾਂਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਸਾਰੇ ਲੇਬਲ ਸਹੀ ਤਰ੍ਹਾਂ ਇੱਕ ਵਾਰ ਐਲਾਨ ਕੀਤੇ ਗਏ ਹਨ।


The scope of labels can be controlled by the symbol table, so labels can be local to a procedure or block.

ਲੇਬਲਾਂ ਦੇ ਦਾਇਰੇ ਨੂੰ ਪ੍ਰਤੀਕ ਟੇਬਲ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਲੇਬਲ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਬਲਾਕ ਲਈ ਸਥਾਨਕ ਹੋ ਸਕਦੇ ਹਨ।


Some languages allow exiting loops from the middle of the loop-body by a break or exit statement.

ਕੁਝ ਭਾਸ਼ਾਵਾਂ ਇੱਕ ਬ੍ਰੇਕ ਜਾਂ ਐਗਜ਼ਿਟ ਸਟੇਟਮੈਂਟ ਦੁਆਰਾ ਲੂਪ-ਬਾਡੀ ਦੇ ਵਿਚਕਾਰੋਂ ਲੂਪਾਂ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ।


To handle these, the translation function for statements must have an extra inherited parameter which is the label that a break or exit statement must jump to.

ਇਹਨਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ, ਬਿਆਨਾਂ ਲਈ ਅਨੁਵਾਦ ਫੰਕਸ਼ਨ ਵਿੱਚ ਇੱਕ ਵਾਧੂ ਵਿਰਾਸਤੀ ਪੈਰਾਮੀਟਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਉਹ ਲੇਬਲ ਹੈ ਜਿਸ 'ਤੇ ਇੱਕ ਬ੍ਰੇਕ ਜਾਂ ਐਗਜ਼ਿਟ ਸਟੇਟਮੈਂਟ ਨੂੰ ਜੰਪ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


This attribute is changed whenever a new loop is entered.

ਜਦੋਂ ਵੀ ਇੱਕ ਨਵਾਂ ਲੂਪ ਦਾਖਲ ਹੁੰਦਾ ਹੈ, ਇਹ ਗੁਣ ਬਦਲ ਜਾਂਦਾ ਹੈ।


Before the first loop is entered, this attribute is undefined.

ਪਹਿਲੇ ਲੂਪ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਗੁਣ ਅਣਡਿੱਠ ਹੈ।


The translation function should check for this, so it can report an error if a break or exit occurs outside loops.

ਅਨੁਵਾਦ ਫੰਕਸ਼ਨ ਨੂੰ ਇਸਦੀ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਇਸ ਲਈ ਇਹ ਇੱਕ ਗਲਤੀ ਦੀ ਰਿਪੋਰਟ ਕਰ ਸਕਦਾ ਹੈ ਜੇਕਰ ਲੂਪਾਂ ਦੇ ਬਾਹਰ ਇੱਕ ਬ੍ਰੇਕ ਜਾਂ ਐਗਜ਼ਿਟ ਹੁੰਦਾ ਹੈ।


This should, rightly, be done during type-checking.

ਇਹ, ਸਹੀ ਢੰਗ ਨਾਲ, ਟਾਈਪ-ਚੈਕਿੰਗ ਦੌਰਾਨ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।


C’s continue statement, which jumps to the start of the current loop, can be handled similarly.

C ਦਾ ਕੰਟੀਨਿਊ ਸਟੇਟਮੈਂਟ, ਜੋ ਮੌਜੂਦਾ ਲੂਪ ਦੀ ਸ਼ੁਰੂਆਤ 'ਤੇ ਜੰਪ ਕਰਦਾ ਹੈ, ਨੂੰ ਵੀ ਇਸੇ ਤਰ੍ਹਾਂ ਸੰਭਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ।


A case-statement evaluates an expression and selects one of several branches (statements) based on the value of the expression.

ਇੱਕ ਕੇਸ-ਸਟੇਟਮੈਂਟ ਇੱਕ ਸਮੀਕਰਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦਾ ਹੈ ਅਤੇ ਸਮੀਕਰਨ ਦੇ ਮੁੱਲ ਦੇ ਅਧਾਰ 'ਤੇ ਕਈ ਸ਼ਾਖਾਵਾਂ (ਬਿਆਨਾਂ) ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ।


In most languages, the case-statement will be exited at the end of each of these statements.

ਜ਼ਿਆਦਾਤਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ, ਕੇਸ-ਸਟੇਟਮੈਂਟ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਬਿਆਨ ਦੇ ਅੰਤ ਵਿੱਚ ਬਾਹਰ ਆ ਜਾਵੇਗਾ।


In this case, the case-statement can be translated as an assignment that stores the value of the expression followed by a nested if-then-else statement.

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਕੇਸ-ਸਟੇਟਮੈਂਟ ਨੂੰ ਇੱਕ ਅਸਾਈਨਮੈਂਟ ਵਜੋਂ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਸਮੀਕਰਨ ਦੇ ਮੁੱਲ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ ਜਿਸਦੇ ਬਾਅਦ ਇੱਕ ਨੇਸਟਡ if-then-else ਸਟੇਟਮੈਂਟ ਹੁੰਦਾ ਹੈ।


We will now look at how these can be translated.

ਅਸੀਂ ਹੁਣ ਦੇਖਾਂਗੇ ਕਿ ਇਹਨਾਂ ਦਾ ਅਨੁਵਾਦ ਕਿਵੇਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


ਅੱਜ ਧੁੱਪ ਬਹੁਤ ਚਮਕ ਰਹੀ ਹੈ।


ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਲੂਣ ਦੇ ਸਕਦੇ ਹੋ?


ਖ਼ਬਰਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਭੂਚਾਲ ਦੀ ਰਿਪੋਰਟ ਆਈ ਹੈ।


He is studying computer science at university.

ਉਹ ਯੂਨੀਵਰਸਿਟੀ ਵਿੱਚ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਦੀ ਪੜ੍ਹਾਈ ਕਰ ਰਿਹਾ ਹੈ।


The company announced its quarterly earnings.

ਕੰਪਨੀ ਨੇ ਆਪਣੀ ਤਿਮਾਹੀ ਆਮਦਨ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਉਹ ਸਫਲ ਹੋਏ।


ਡਾਕਟਰ ਨੇ ਉਸਨੂੰ ਆਰਾਮ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ।


ਮੀਟਿੰਗ ਕੱਲ੍ਹ ਹੋਵੇਗੀ।


She enjoys reading novels in her free time.

ਉਹ ਆਪਣੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਨਾਵਲ ਪੜ੍ਹਨਾ ਪਸੰਦ ਕਰਦੀ ਹੈ।


The research paper was published last month.

ਖੋਜ ਪੱਤਰ ਪਿਛਲੇ ਮਹੀਨੇ ਪ੍ਰਕਾਸ਼ਿਤ ਹੋਇਆ ਸੀ।


The engine requires regular maintenance.

ਇੰਜਣ ਨੂੰ ਨਿਯਮਤ ਰੱਖ-ਰਖਾਅ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


ਉਹ ਇੱਕ ਬਹੁਤ ਹੀ ਹੁਨਰਮੰਦ ਪ੍ਰੋਗਰਾਮਰ ਹੈ।


The government implemented new policies.

ਸਰਕਾਰ ਨੇ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕੀਤੀਆਂ।


The data analysis revealed interesting insights.

ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਨੇ ਦਿਲਚਸਪ ਸੂਝਾਂ ਦਾ ਖੁਲਾਸਾ ਕੀਤਾ।


The artist's work is displayed in the gallery.

ਕਲਾਕਾਰ ਦਾ ਕੰਮ ਗੈਲਰੀ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ।


ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕੁਝ ਦੇਰੀ ਹੋ ਰਹੀ ਹੈ।


ਮੌਸਮ ਵਿਭਾਗ ਨੇ ਮੀਂਹ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕੀਤੀ ਹੈ।


ਉਹ ਕਈ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਪ੍ਰਵਾਹਮਾਨ ਹੈ।


The company is expanding its operations globally.

ਕੰਪਨੀ ਵਿਸ਼ਵ ਪੱਧਰ 'ਤੇ ਆਪਣੇ ਕੰਮ ਦਾ ਵਿਸਤਾਰ ਕਰ ਰਹੀ ਹੈ।


The compiler ensures symbol tables contain necessary information for translation.

ਕੰਪਾਈਲਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪ੍ਰਤੀਕ ਟੇਬਲ ਵਿੱਚ ਅਨੁਵਾਦ ਲਈ ਜ਼ਰੂਰੀ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੈ।


For scalar variables, the information includes the intermediate-language variable.

ਸਕੇਲਰ ਵੇਰੀਏਬਲਾਂ ਲਈ, ਜਾਣਕਾਰੀ ਵਿੱਚ ਵਿਚਕਾਰਲੀ-ਭਾਸ਼ਾ ਦਾ ਵੇਰੀਏਬਲ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ।


The symbol table must provide a description of the type.

ਪ੍ਰਤੀਕ ਟੇਬਲ ਨੂੰ ਕਿਸਮ ਦਾ ਵਰਣਨ ਪ੍ਰਦਾਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


Translation of function declarations will be treated in chapter 10.

ਫੰਕਸ਼ਨ ਘੋਸ਼ਣਾਵਾਂ ਦਾ ਅਨੁਵਾਦ ਅਧਿਆਇ 10 ਵਿੱਚ ਕੀਤਾ ਜਾਵੇਗਾ।


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

ਅਸੀਂ ਇੰਟੀਜਰ ਵੇਰੀਏਬਲ ਅਤੇ ਇੱਕ-ਅਯਾਮੀ ਇੰਟੀਜਰ ਐਰੇ ਘੋਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਾਂ।


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

ਇੱਕ ਐਰੇ ਨੂੰ ਇੱਕ ਵੇਰੀਏਬਲ ਨਾਲ ਬੰਨ੍ਹਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇਸਦਾ ਬੇਸ ਐਡਰੈੱਸ ਹੁੰਦਾ ਹੈ।


ਅਸੀਂ ਮੰਨਦੇ ਹਾਂ ਕਿ ਐਰੇ ਹੀਪ ਅਲਾਟ ਕੀਤੇ ਗਏ ਹਨ।


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

ਵਿਚਕਾਰਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਬਾਰੇ ਇੱਕ ਵਿਆਪਕ ਚਰਚਾ [35] ਵਿੱਚ ਮਿਲ ਸਕਦੀ ਹੈ।


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

ਕਾਰਜਸ਼ੀਲ ਅਤੇ ਤਰਕ ਭਾਸ਼ਾਵਾਂ ਅਕਸਰ ਉੱਚ-ਪੱਧਰੀ ਵਿਚਕਾਰਲੀਆਂ ਭਾਸ਼ਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ।


This language has single instructions for such complex things as calling virtual methods.

ਇਸ ਭਾਸ਼ਾ ਵਿੱਚ ਵਰਚੁਅਲ ਤਰੀਕਿਆਂ ਨੂੰ ਕਾਲ ਕਰਨ ਵਰਗੀਆਂ ਗੁੰਝਲਦਾਰ ਚੀਜ਼ਾਂ ਲਈ ਸਿੰਗਲ ਹਦਾਇਤਾਂ ਹਨ।


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

ਆਮ ਗੁੰਝਲਦਾਰ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸਿੰਗਲ ਹਦਾਇਤਾਂ ਦੁਆਰਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇ ਕੇ, ਕੋਡ ਛੋਟਾ ਹੁੰਦਾ ਹੈ।


JVM was originally intended for interpretation.

JVM ਅਸਲ ਵਿੱਚ ਵਿਆਖਿਆ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ।


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

JVM ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਵਿਆਖਿਆ ਜਾਂ ਅੱਗੇ ਅਨੁਵਾਦ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਮਾਣਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


Use the translation functions in figure 7.3 to generate code.

ਕੋਡ ਤਿਆਰ ਕਰਨ ਲਈ ਚਿੱਤਰ 7.3 ਵਿੱਚ ਅਨੁਵਾਦ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।


The result of the expression should be put in the intermediate-code variable r.

ਇਸ ਸਮੀਕਰਨ ਦਾ ਨਤੀਜਾ ਵਿਚਕਾਰਲੇ-ਕੋਡ ਵੇਰੀਏਬਲ r ਵਿੱਚ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।


ਅਭਿਆਸ 7.1 ਵਿੱਚ ਵਾਂਗ ਹੀ vtable ਦੀ ਵਰਤੋਂ ਕਰੋ।


De Morgan’s law tells us that !(p || q) is equivalent to (!p) && (!q).

ਡੀ ਮੋਰਗਨ ਦਾ ਨਿਯਮ ਸਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ !(p || q) (!p) && (!q) ਦੇ ਬਰਾਬਰ ਹੈ।


Show that these generate identical code when compiled.

ਦਿਖਾਓ ਕਿ ਇਹ ਕੰਪਾਇਲ ਹੋਣ 'ਤੇ ਇੱਕੋ ਜਿਹਾ ਕੋਡ ਤਿਆਰ ਕਰਦੇ ਹਨ।


Extend figure 7.5 to include a break-statement for exiting loops.

ਲੂਪਾਂ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਲਈ ਇੱਕ ਬ੍ਰੇਕ-ਸਟੇਟਮੈਂਟ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਚਿੱਤਰ 7.5 ਦਾ ਵਿਸਤਾਰ ਕਰੋ।


Labels have scope over the entire program.

ਲੇਬਲਾਂ ਦਾ ਸਕੋਪ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਹੁੰਦਾ ਹੈ।


The algorithm is used to solve the problem of register allocation.

ਇਹ ਐਲਗੋਰਿਦਮ ਰਜਿਸਟਰ ਅਲਾਟਮੈਂਟ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।


If there is no node with less than N edges, pick any node and do as above.

ਜੇਕਰ ਕੋਈ ਅਜਿਹਾ ਨੋਡ ਨਹੀਂ ਹੈ ਜਿਸ ਵਿੱਚ N ਤੋਂ ਘੱਟ ਕਿਨਾਰੇ ਹਨ, ਤਾਂ ਕਿਸੇ ਵੀ ਨੋਡ ਨੂੰ ਚੁਣੋ ਅਤੇ ਉੱਪਰ ਦੱਸੇ ਅਨੁਸਾਰ ਕਰੋ।


The program is designed to manage memory efficiently.

ਇਹ ਪ੍ਰੋਗਰਾਮ ਮੈਮੋਰੀ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ।


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

ਸਪਿਲਿੰਗ ਉਹ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸ ਵਿੱਚ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਰਜਿਸਟਰਾਂ ਤੋਂ ਮੈਮੋਰੀ ਵਿੱਚ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ।


We will look at some ideas for making qualified guesses.

ਅਸੀਂ ਕੁਆਲੀਫਾਈਡ ਅਨੁਮਾਨ ਲਗਾਉਣ ਲਈ ਕੁਝ ਵਿਚਾਰਾਂ 'ਤੇ ਗੌਰ ਕਰਾਂਗੇ।


The register allocator can try to remove some of the inserted moves.

ਰਜਿਸਟਰ ਅਲਾਕੇਟਰ ਕੁਝ ਪਾਈਆਂ ਗਈਆਂ ਮੂਵਜ਼ ਨੂੰ ਹਟਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦਾ ਹੈ।


ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਪਿਲਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


The function call instruction must be translated into a call-sequence.

ਫੰਕਸ਼ਨ ਕਾਲ ਨਿਰਦੇਸ਼ ਨੂੰ ਇੱਕ ਕਾਲ-ਸੀਕੁਐਂਸ ਵਿੱਚ ਅਨੁਵਾਦ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।


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

ਹਰੇਕ ਫੰਕਸ਼ਨ ਇਨਵੋਕੇਸ਼ਨ ਸਟੈਕ 'ਤੇ ਮੈਮੋਰੀ ਦਾ ਇੱਕ ਟੁਕੜਾ ਅਲਾਟ ਕਰੇਗਾ।


The stack can also be used for other purposes.

ਸਟੈਕ ਦੀ ਵਰਤੋਂ ਹੋਰ ਉਦੇਸ਼ਾਂ ਲਈ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।


The compiler textbooks show some other variants and a few newer developments.

ਕੰਪਾਈਲਰ ਪਾਠ-ਪੁਸਤਕਾਂ ਕੁਝ ਹੋਰ ਰੂਪਾਂ ਅਤੇ ਕੁਝ ਨਵੇਂ ਵਿਕਾਸਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ।


We will initially assume that all variables are local.

ਅਸੀਂ ਸ਼ੁਰੂ ਵਿੱਚ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਸਾਰੇ ਵੇਰੀਏਬਲ ਸਥਾਨਕ ਹਨ।


This is the default parameter-passing mechanism in most languages.

ਇਹ ਜ਼ਿਆਦਾਤਰ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਡਿਫਾਲਟ ਪੈਰਾਮੀਟਰ-ਪਾਸਿੰਗ ਵਿਧੀ ਹੈ।


A single procedure body uses a finite number of variables.

ਇੱਕ ਸਿੰਗਲ ਪ੍ਰਕਿਰਿਆ ਬਾਡੀ ਸੀਮਤ ਗਿਣਤੀ ਵਿੱਚ ਵੇਰੀਏਬਲ ਵਰਤਦੀ ਹੈ।


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

ਅਸੀਂ ਇਨ੍ਹਾਂ ਸਾਰੇ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਰੱਖਣ ਦੀ ਉਮੀਦ ਨਹੀਂ ਕਰ ਸਕਦੇ।


When a function is called, all the live variables of the calling function will be stored in memory.

ਜਦੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਕਾਲਿੰਗ ਫੰਕਸ਼ਨ ਦੇ ਸਾਰੇ ਲਾਈਵ ਵੇਰੀਏਬਲ ਮੈਮੋਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਣਗੇ।


It is convenient to use a stack for this storing and loading.

ਇਸ ਸਟੋਰੇਜ ਅਤੇ ਲੋਡਿੰਗ ਲਈ ਇੱਕ ਸਟੈਕ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੁਵਿਧਾਜਨਕ ਹੈ।


Each function invocation will allocate a chunk of memory on the stack to cover all of the function’s needs.

ਹਰੇਕ ਫੰਕਸ਼ਨ ਇਨਵੋਕੇਸ਼ਨ ਫੰਕਸ਼ਨ ਦੀਆਂ ਸਾਰੀਆਂ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਸਟੈਕ 'ਤੇ ਮੈਮੋਰੀ ਦਾ ਇੱਕ ਟੁਕੜਾ ਅਲਾਟ ਕਰੇਗਾ।


We will start by defining very simple activation records.

ਅਸੀਂ ਬਹੁਤ ਹੀ ਸਧਾਰਨ ਐਕਟੀਵੇਸ਼ਨ ਰਿਕਾਰਡਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂਆਤ ਕਰਾਂਗੇ।


ਫ਼ੰਕਸ਼ਨ ਕਾਲ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ।


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

ਪੈਰਾਮੀਟਰ ਅਤੇ ਵਾਪਸੀ ਦਾ ਪਤਾ ਨਵੇਂ ਫਰੇਮ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।


The caller saves all registers that must be preserved.

ਕਾਲਰ ਉਹ ਸਾਰੇ ਰਜਿਸਟਰ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ ਜ਼ਰੂਰੀ ਹੈ।


ਇਸ ਰਣਨੀਤੀ ਨੂੰ ਕੈਲੀ-ਸੇਵਜ਼ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


We will return to this issue in section 10.6.

ਅਸੀਂ ਇਸ ਮੁੱਦੇ 'ਤੇ ਭਾਗ 10.6 ਵਿੱਚ ਵਾਪਸ ਆਵਾਂਗੇ।


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

ਕਾਲਰ-ਸੇਵਜ਼ ਨੂੰ ਸਿਰਫ਼ ਉਹ ਰਜਿਸਟਰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਜੋ ਲਾਈਵ ਵੇਰੀਏਬਲ ਰੱਖਦੇ ਹਨ।


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.

ਜ਼ਿਆਦਾਤਰ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਕਾਫ਼ੀ ਛੋਟੀਆਂ ਪੈਰਾਮੀਟਰ ਸੂਚੀਆਂ ਹੁੰਦੀਆਂ ਹਨ।


A possible division of registers for a 16-register architecture is shown in figure 10.7.

16-ਰਜਿਸਟਰ ਆਰਕੀਟੈਕਚਰ ਲਈ ਰਜਿਸਟਰਾਂ ਦੀ ਇੱਕ ਸੰਭਾਵਿਤ ਵੰਡ ਚਿੱਤਰ 10.7 ਵਿੱਚ ਦਿਖਾਈ ਗਈ ਹੈ।


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

ਧਿਆਨ ਦਿਓ ਕਿ ਵਾਪਸੀ ਦਾ ਪਤਾ ਵੀ ਇੱਕ ਰਜਿਸਟਰ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The register allocator can be used to optimise function calls.

ਰਜਿਸਟਰ ਅਲਾਕੇਟਰ ਦੀ ਵਰਤੋਂ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।


The compiler needs to generate code for the body of the function.

ਕੰਪਾਈਲਰ ਨੂੰ ਫੰਕਸ਼ਨ ਦੇ ਸਰੀਰ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


Global variables will be stored in memory.

ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਮੈਮੋਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਜਾਣਗੇ।


The location of each global variable will be known at compile-time or link-time.

ਹਰੇਕ ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਦਾ ਸਥਾਨ ਕੰਪਾਈਲ-ਟਾਈਮ ਜਾਂ ਲਿੰਕ-ਟਾਈਮ 'ਤੇ ਜਾਣਿਆ ਜਾਵੇਗਾ।


Good programmers will use global variables sparingly.

ਚੰਗੇ ਪ੍ਰੋਗਰਾਮਰ ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਦੀ ਘੱਟ ਵਰਤੋਂ ਕਰਨਗੇ।


Call-by-reference is implemented by passing the address of the variable.

ਕਾਲ-ਬਾਈ-ਰੈਫਰੈਂਸ ਵੇਰੀਏਬਲ ਦਾ ਪਤਾ ਪਾਸ ਕਰਕੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


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

C ਵਿੱਚ, ਕੋਈ ਸਪੱਸ਼ਟ ਕਾਲ-ਬਾਈ-ਰੈਫਰੈਂਸ ਪੈਰਾਮੀਟਰ ਨਹੀਂ ਹਨ।


Nested scopes allow functions to be declared locally within other functions.

ਨੈਸਟਡ ਸਕੋਪ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਦੂਜੇ ਫੰਕਸ਼ਨਾਂ ਦੇ ਅੰਦਰ ਸਥਾਨਕ ਤੌਰ 'ਤੇ ਘੋਸ਼ਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ।


All variables that can be accessed in inner scopes need to be stored in memory.

ਉਹ ਸਾਰੇ ਵੇਰੀਏਬਲ ਜਿਨ੍ਹਾਂ ਨੂੰ ਅੰਦਰੂਨੀ ਸਕੋਪ ਵਿੱਚ ਐਕਸੈਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


ਅੱਜ ਸੂਰਜ ਬਹੁਤ ਚਮਕ ਰਿਹਾ ਹੈ।


ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਨਮਕ ਦੇ ਸਕਦੇ ਹੋ?


ਖ਼ਬਰਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਭੂਚਾਲ ਦੀ ਰਿਪੋਰਟ ਦਿੱਤੀ ਗਈ।


He is studying computer science at university.

ਉਹ ਯੂਨੀਵਰਸਿਟੀ ਵਿੱਚ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਦੀ ਪੜ੍ਹਾਈ ਕਰ ਰਿਹਾ ਹੈ।


The company announced a new product launch.

ਕੰਪਨੀ ਨੇ ਇੱਕ ਨਵੇਂ ਉਤਪਾਦ ਦੀ ਸ਼ੁਰੂਆਤ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਉਹ ਸਫਲ ਹੋਏ।


The government implemented new policies.

ਸਰਕਾਰ ਨੇ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕੀਤੀਆਂ।


She enjoys reading novels in her free time.

ਉਹ ਆਪਣੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਨਾਵਲ ਪੜ੍ਹਨਾ ਪਸੰਦ ਕਰਦੀ ਹੈ।


The research team published their findings.

ਖੋਜ ਟੀਮ ਨੇ ਆਪਣੇ ਖੋਜ ਨਤੀਜੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ।


ਸਾਫਟਵੇਅਰ ਨੂੰ ਅਕਸਰ ਅਪਡੇਟਸ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


ਉਹ ਇੱਕ ਬਹੁਤ ਹੀ ਹੁਨਰਮੰਦ ਪੇਸ਼ੇਵਰ ਹੈ।


The economic situation is improving gradually.

ਆਰਥਿਕ ਸਥਿਤੀ ਹੌਲੀ-ਹੌਲੀ ਸੁਧਰ ਰਹੀ ਹੈ।


ਅਜਾਇਬ ਘਰ ਪ੍ਰਾਚੀਨ ਕਲਾਕ੍ਰਿਤੀਆਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦਾ ਹੈ।


ਕੱਲ੍ਹ ਇਕਰਾਰਨਾਮੇ 'ਤੇ ਦਸਤਖਤ ਕੀਤੇ ਗਏ ਸਨ।


The complex system needs careful maintenance.

ਗੁੰਝਲਦਾਰ ਪ੍ਰਣਾਲੀ ਨੂੰ ਧਿਆਨ ਨਾਲ ਦੇਖਭਾਲ ਦੀ ਲੋੜ ਹੈ।


ਕਲਾਕਾਰ ਦਾ ਕੰਮ ਬਹੁਤ ਪ੍ਰਸ਼ੰਸਾਯੋਗ ਹੈ।


The company is expanding its operations globally.

ਕੰਪਨੀ ਵਿਸ਼ਵ ਪੱਧਰ 'ਤੇ ਆਪਣੇ ਕੰਮ ਦਾ ਵਿਸਤਾਰ ਕਰ ਰਹੀ ਹੈ।


The scientific study provided valuable insights.

ਵਿਗਿਆਨਕ ਅਧਿਐਨ ਨੇ ਕੀਮਤੀ ਸੂਝ ਪ੍ਰਦਾਨ ਕੀਤੀ।


ਰਾਜਨੀਤਿਕ ਬਹਿਸ ਬਹੁਤ ਤੀਬਰ ਸੀ।


The program calculates the sum of numbers.

ਇਹ ਪ੍ਰੋਗਰਾਮ ਅੰਕਾਂ ਦਾ ਜੋੜ ਕੱਢਦਾ ਹੈ।


ਕਿਰਪਾ ਕਰਕੇ ਆਪਣਾ ਨਾਮ ਅਤੇ ਪਤਾ ਦਰਜ ਕਰੋ।


ਅੱਜ ਮੌਸਮ ਬਹੁਤ ਸੁਹਾਵਣਾ ਹੈ।


He is going to the market to buy vegetables.

ਉਹ ਸਬਜ਼ੀਆਂ ਖਰੀਦਣ ਲਈ ਬਾਜ਼ਾਰ ਜਾ ਰਿਹਾ ਹੈ।


Data-flow analysis is crucial for compiler optimization.

ਕੰਪਾਈਲਰ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਲਈ ਡਾਟਾ-ਫਲੋ ਵਿਸ਼ਲੇਸ਼ਣ ਜ਼ਰੂਰੀ ਹੈ।


The algorithm efficiently sorts the given array.

ਐਲਗੋਰਿਦਮ ਦਿੱਤੇ ਗਏ ਅਰੇ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


The government is implementing new policies.

ਸਰਕਾਰ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ।


She enjoys reading books in her free time.

ਉਹ ਆਪਣੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਕਿਤਾਬਾਂ ਪੜ੍ਹਨਾ ਪਸੰਦ ਕਰਦੀ ਹੈ।


The meeting will be held tomorrow morning.

ਮੀਟਿੰਗ ਕੱਲ੍ਹ ਸਵੇਰੇ ਹੋਵੇਗੀ।


The compiler performs common subexpression elimination.

ਕੰਪਾਈਲਰ ਆਮ ਸਬਐਕਸਪ੍ਰੈਸ਼ਨ ਨੂੰ ਖਤਮ ਕਰਦਾ ਹੈ।


The code hoisting optimization improves performance.

ਕੋਡ ਹੋਇਸਟਿੰਗ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੀ ਹੈ।


The index-check elimination reduces overhead.

ਇੰਡੈਕਸ-ਚੈੱਕ ਖਾਤਮਾ ਓਵਰਹੈੱਡ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ।


The function call optimization is important.

ਫੰਕਸ਼ਨ ਕਾਲ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The prefetching technique enhances memory access.

ਪ੍ਰੀਫੈਚਿੰਗ ਤਕਨੀਕ ਮੈਮੋਰੀ ਪਹੁੰਚ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ।


ਪ੍ਰੋਗਰਾਮ ਦੁਹਰਾਓ ਲਈ ਇੱਕ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The weather forecast predicts rain tomorrow.

ਮੌਸਮ ਵਿਭਾਗ ਕੱਲ੍ਹ ਮੀਂਹ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ।


ਉਹ ਇੱਕ ਬਹੁਤ ਹੀ ਪ੍ਰਤਿਭਾਸ਼ਾਲੀ ਸੰਗੀਤਕਾਰ ਹੈ।


The project deadline is approaching fast.

ਪ੍ਰੋਜੈਕਟ ਦੀ ਆਖਰੀ ਤਾਰੀਖ ਤੇਜ਼ੀ ਨਾਲ ਨੇੜੇ ਆ ਰਹੀ ਹੈ।


The function's purpose is to optimize code execution.

ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਮਕਸਦ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਹੈ।


Tail-call optimization can save stack space.

ਟੇਲ-ਕਾਲ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਸਟੈਕ ਸਪੇਸ ਬਚਾ ਸਕਦੀ ਹੈ।


The compiler performs various optimizations.

ਕੰਪਾਈਲਰ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਕਰਦਾ ਹੈ।


Specialization can improve the speed of execution.

ਵਿਸ਼ੇਸ਼ਤਾ ਕਾਰਜ ਦੀ ਗਤੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰ ਸਕਦੀ ਹੈ।


Memory management is a crucial aspect of programming.

ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਹੈ।


Static allocation occurs at compile time.

ਸਟੈਟਿਕ ਅਲਾਟਮੈਂਟ ਕੰਪਾਈਲ ਟਾਈਮ ਤੇ ਹੁੰਦਾ ਹੈ।


ਸਟੈਕ ਅਲਾਟਮੈਂਟ ਮੁਕਾਬਲਤਨ ਤੇਜ਼ ਹੈ।


Heap allocation allows for dynamic memory.

ਹੀਪ ਅਲਾਟਮੈਂਟ ਡਾਇਨਾਮਿਕ ਮੈਮੋਰੀ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।


Manual memory management uses malloc and free.

ਮੈਨੂਅਲ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਮੈਲੋਕ ਅਤੇ ਫ੍ਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Fragmentation can be a problem in heap allocation.

ਹੀਪ ਅਲਾਟਮੈਂਟ ਵਿੱਚ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਇੱਕ ਸਮੱਸਿਆ ਹੋ ਸਕਦੀ ਹੈ।


The program needs to allocate memory for the array.

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਐਰੇ ਲਈ ਮੈਮੋਰੀ ਅਲਾਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


ਕੋਡ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ।


The compiler optimizes the program's performance.

ਕੰਪਾਈਲਰ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ।


The function is called with constant parameters.

ਫੰਕਸ਼ਨ ਨੂੰ ਸਥਿਰ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ।


The program uses a caller-saves strategy.

ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਕਾਲਰ-ਸੇਵ ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The code simplifies the combined call sequence.

ਕੋਡ ਸੰਯੁਕਤ ਕਾਲ ਸੀਕੁਐਂਸ ਨੂੰ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ।


ਫੰਕਸ਼ਨ ਇੱਕ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।


The program avoids overwriting the return address.

ਪ੍ਰੋਗਰਾਮ ਵਾਪਸੀ ਪਤੇ ਨੂੰ ਓਵਰਰਾਈਟ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ।


The compiler optimizes the code for speed.

ਕੰਪਾਈਲਰ ਗਤੀ ਲਈ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ।


The function is specialized for a specific case.

ਫੰਕਸ਼ਨ ਇੱਕ ਖਾਸ ਮਾਮਲੇ ਲਈ ਵਿਸ਼ੇਸ਼ ਹੈ।


The garbage collector moves data to free up memory.

ਕੂੜਾ ਇਕੱਠਾ ਕਰਨ ਵਾਲਾ ਡਾਟਾ ਨੂੰ ਮੈਮੋਰੀ ਖਾਲੀ ਕਰਨ ਲਈ ਹਿਲਾਉਂਦਾ ਹੈ।


Generational collectors are used to reduce the problem of long-lived blocks.

ਪੀੜ੍ਹੀਗਤ ਕੁਲੈਕਟਰ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੇ ਬਲਾਕਾਂ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਘਟਾਉਣ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।


The program needs to react quickly to outside changes.

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਾਹਰੀ ਤਬਦੀਲੀਆਂ 'ਤੇ ਤੁਰੰਤ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


Automatic memory management distinguishes heap-pointers from other values.

ਆਟੋਮੈਟਿਕ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਹੀਪ-ਪੁਆਇੰਟਰਾਂ ਨੂੰ ਹੋਰ ਮੁੱਲਾਂ ਤੋਂ ਵੱਖ ਕਰਦਾ ਹੈ।


The compiler translates code from one language to another.

ਕੰਪਾਈਲਰ ਇੱਕ ਭਾਸ਼ਾ ਤੋਂ ਦੂਜੀ ਭਾਸ਼ਾ ਵਿੱਚ ਕੋਡ ਦਾ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ।


Bootstrapping is a process used to create compilers.

ਬੂਟਸਟ੍ਰੈਪਿੰਗ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜੋ ਕੰਪਾਈਲਰ ਬਣਾਉਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।


The machine directly executes language D.

ਮਸ਼ੀਨ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਭਾਸ਼ਾ ਡੀ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ।


We want a compiler for ML to x86 machine code.

ਅਸੀਂ ML ਤੋਂ x86 ਮਸ਼ੀਨ ਕੋਡ ਲਈ ਇੱਕ ਕੰਪਾਈਲਰ ਚਾਹੁੰਦੇ ਹਾਂ।


This introduces several problems in the process.

ਇਹ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕਈ ਸਮੱਸਿਆਵਾਂ ਪੇਸ਼ ਕਰਦਾ ਹੈ।


The compiler can now be used to compile itself.

ਕੰਪਾਈਲਰ ਹੁਣ ਆਪਣੇ ਆਪ ਨੂੰ ਕੰਪਾਈਲ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।


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

ਬੂਟਸਟ੍ਰੈਪਿੰਗ ਦਾ ਮੁਢਲਾ ਵਿਚਾਰ ਕੰਪਾਈਲਰਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਨੂੰ ਕੰਪਾਈਲ ਕਰਨ ਲਈ ਵਰਤਣਾ ਹੈ।


The input to the compiler is the source program.

ਕੰਪਾਈਲਰ ਦਾ ਇਨਪੁਟ ਸਰੋਤ ਪ੍ਰੋਗਰਾਮ ਹੈ।


The resulting output is the target program.

ਨਤੀਜਾ ਆਉਟਪੁੱਟ ਟੀਚਾ ਪ੍ਰੋਗਰਾਮ ਹੈ।


Such combinations can be a bit confusing.

ਅਜਿਹੇ ਸੁਮੇਲ ਥੋੜੇ ਉਲਝਣ ਵਾਲੇ ਹੋ ਸਕਦੇ ਹਨ।


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

ਜਦੋਂ ਕੋਈ ਮੌਜੂਦਾ ਕੰਪਾਈਲਰ ਉਪਲਬਧ ਨਹੀਂ ਹੁੰਦਾ, ਤਾਂ ਸਾਨੂੰ ਇੱਕ ਪੂਰਾ ਬੂਟਸਟ੍ਰੈਪ ਚਾਹੀਦਾ ਹੁੰਦਾ ਹੈ।


ਕੰਪਾਈਲਰ ਭਾਸ਼ਾ ਬੀ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ।


The program is running on the x86 platform.

ਪ੍ਰੋਗਰਾਮ x86 ਪਲੇਟਫਾਰਮ 'ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ।


The language must allow pointer values to change.

ਭਾਸ਼ਾ ਨੂੰ ਪੁਆਇੰਟਰ ਮੁੱਲਾਂ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ।


Collection time is proportional only to the live nodes.

ਕਲੈਕਸ਼ਨ ਦਾ ਸਮਾਂ ਸਿਰਫ਼ ਲਾਈਵ ਨੋਡਾਂ ਦੇ ਅਨੁਪਾਤਕ ਹੁੰਦਾ ਹੈ।


Generational collection can speed up copying collectors.

ਪੀੜ੍ਹੀਗਤ ਸੰਗ੍ਰਹਿ ਕਾਪੀ ਕਰਨ ਵਾਲੇ ਕੁਲੈਕਟਰਾਂ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦਾ ਹੈ।


When freeing a block, we subtract one from the size.

ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਬਲਾਕ ਨੂੰ ਖਾਲੀ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਆਕਾਰ ਵਿੱਚੋਂ ਇੱਕ ਘਟਾਉਂਦੇ ਹਾਂ।


If so, we add the sizes and store the sum in the size field of the released block.

ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਆਕਾਰਾਂ ਨੂੰ ਜੋੜਦੇ ਹਾਂ ਅਤੇ ਜੋੜ ਨੂੰ ਰਿਲੀਜ਼ ਕੀਤੇ ਬਲਾਕ ਦੇ ਆਕਾਰ ਖੇਤਰ ਵਿੱਚ ਸਟੋਰ ਕਰਦੇ ਹਾਂ।


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

ਧਿਆਨ ਦਿਓ ਕਿ ਬਲਾਕਾਂ ਨੂੰ ਖਾਲੀ ਕਰਨ ਦਾ ਕ੍ਰਮ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਕੀ ਬਲਾਕ ਜੁੜੇ ਹੋਏ ਹਨ।


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

ਇਸ ਸੋਧ ਦੇ ਨਾਲ, free() ਦੁਬਾਰਾ ਸਥਿਰ ਸਮਾਂ ਹੈ, ਪਰ ਅਸੀਂ ਹੋਰਨਾਂ ਨਾਲੋਂ ਘੱਟ ਬਲਾਕਾਂ ਨੂੰ ਮਿਲਾਉਂਦੇ ਹਾਂ।


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

malloc() ਨੂੰ ਕਾਲ ਕਰਦੇ ਸਮੇਂ ਇੱਕ ਕਾਫ਼ੀ ਵੱਡੇ ਬਲਾਕ ਦੀ ਖੋਜ ਲਈ ਵਰਤੇ ਗਏ ਸਮੇਂ ਨੂੰ ਘਟਾਉਣ ਲਈ, ਅਸੀਂ ਮੁਫਤ ਬਲਾਕਾਂ ਨੂੰ ਆਕਾਰ ਅਨੁਸਾਰ ਕ੍ਰਮਬੱਧ ਰੱਖ ਸਕਦੇ ਹਾਂ।


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.

ਜੇਕਰ ਸੰਬੰਧਿਤ ਮੁਫਤ ਸੂਚੀ ਖਾਲੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਅਗਲੀ ਮੁਫਤ ਸੂਚੀ ਵਿੱਚ ਪਹਿਲਾ ਬਲਾਕ ਲੈਂਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਦੋ ਬਰਾਬਰ ਆਕਾਰ ਦੇ ਬਲਾਕਾਂ ਵਿੱਚ ਵੰਡਦੇ ਹਾਂ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਪਿਛਲੀ ਮੁਫਤ ਸੂਚੀ ਵਿੱਚ ਪਾਉਂਦੇ ਹਾਂ ਅਤੇ ਦੂਜੇ ਨੂੰ ਵਾਪਸ ਕਰਦੇ ਹਾਂ।


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

ਫ੍ਰੈਗਮੈਂਟੇਸ਼ਨ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਮੁਕਤ ਬਲਾਕਾਂ ਦੇ ਤੇਜ਼ੀ ਨਾਲ ਜੁੜਨ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ, ਕੁਝ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਕ ਬਲਾਕਾਂ ਨੂੰ ਬਲਾਕ ਆਕਾਰ ਨਾਲ ਅਲਾਈਨ ਕਰਨ ਤੱਕ ਸੀਮਤ ਕਰਦੇ ਹਨ।


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

ਦੋ ਬਲਾਕ ਜਿਨ੍ਹਾਂ ਨੂੰ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਨੂੰ “ਬੱਡੀ” ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਬਲਾਕ ਦਾ ਇੱਕ ਵਿਲੱਖਣ ਬੱਡੀ ਹੁੰਦਾ ਹੈ।


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

ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਬਲਾਕ ਨੂੰ ਖਾਲੀ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਇਸ ਬਿੱਟ ਨੂੰ ਸਾਫ਼ ਕਰਦੇ ਹਾਂ ਅਤੇ ਬੱਡੀ ਦੇ ਆਕਾਰ ਖੇਤਰ ਨੂੰ ਦੇਖਦੇ ਹਾਂ।


With the buddy system, we get both malloc() and free() down to logarithmic time, but we use extra space by rounding allocation sizes up to powers of two.

ਬੱਡੀ ਸਿਸਟਮ ਦੇ ਨਾਲ, ਅਸੀਂ malloc() ਅਤੇ free() ਦੋਵਾਂ ਨੂੰ ਲਘੂਗਣਕ ਸਮੇਂ ਤੱਕ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ, ਪਰ ਅਸੀਂ ਅਲਾਟਮੈਂਟ ਆਕਾਰਾਂ ਨੂੰ ਦੋ ਦੀਆਂ ਸ਼ਕਤੀਆਂ ਤੱਕ ਗੋਲ ਕਰਕੇ ਵਾਧੂ ਥਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।


This waste is sometimes called internal fragmentation, where having many small free blocks is called external fragmentation.

ਇਸ ਬਰਬਾਦੀ ਨੂੰ ਕਈ ਵਾਰ ਅੰਦਰੂਨੀ ਫ੍ਰੈਗਮੈਂਟੇਸ਼ਨ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ ਬਹੁਤ ਸਾਰੇ ਛੋਟੇ ਮੁਫਤ ਬਲਾਕਾਂ ਦਾ ਹੋਣਾ ਬਾਹਰੀ ਫ੍ਰੈਗਮੈਂਟੇਸ਼ਨ ਅਖਵਾਉਂਦਾ ਹੈ।


For example, we might get a heap that alternates between four-word blocks that are in use and four-word blocks that are free.

ਉਦਾਹਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਢੇਰ ਮਿਲ ਸਕਦਾ ਹੈ ਜੋ ਚਾਰ-ਸ਼ਬਦ ਬਲਾਕਾਂ ਜੋ ਵਰਤੋਂ ਵਿੱਚ ਹਨ ਅਤੇ ਚਾਰ-ਸ਼ਬਦ ਬਲਾਕਾਂ ਜੋ ਮੁਫਤ ਹਨ, ਦੇ ਵਿਚਕਾਰ ਬਦਲਦਾ ਹੈ।


Manual memory management means that both allocation and deallocation of heap-allocated objects (arrays etc.) is explicit in the code.

ਮੈਨੂਅਲ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਢੇਰ-ਅਲਾਟਿਡ ਆਬਜੈਕਟ (ਐਰੇ ਆਦਿ) ਦੀ ਅਲਾਟਮੈਂਟ ਅਤੇ ਡੀਅਲੋਕੇਸ਼ਨ ਦੋਵੇਂ ਕੋਡ ਵਿੱਚ ਸਪੱਸ਼ਟ ਹਨ।


In C, this is done using the library functions malloc() and free().

C ਵਿੱਚ, ਇਹ ਲਾਇਬ੍ਰੇਰੀ ਫੰਕਸ਼ਨ malloc() ਅਤੇ free() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


It is possible to get allocation (malloc() time down to logarithmic in the size of memory.

ਇਹ ਮੈਮੋਰੀ ਦੇ ਆਕਾਰ ਵਿੱਚ ਲਘੂਗਣਕ ਤੱਕ ਅਲਾਟਮੈਂਟ (malloc() ਸਮਾਂ) ਪ੍ਰਾਪਤ ਕਰਨਾ ਸੰਭਵ ਹੈ।


Manually inserting calls to free() in the program is error-prone and a common source of errors.

ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ free() ਨੂੰ ਹੱਥੀਂ ਸ਼ਾਮਲ ਕਰਨਾ ਗਲਤੀ-ਪ੍ਰਵਿਰਤੀ ਵਾਲਾ ਹੈ ਅਤੇ ਗਲਤੀਆਂ ਦਾ ਇੱਕ ਆਮ ਸਰੋਤ ਹੈ।


If memory is used after it is erroneously freed, the results can be unpredictable and compromise the security of a software system.

ਜੇਕਰ ਗਲਤੀ ਨਾਲ ਖਾਲੀ ਹੋਣ ਤੋਂ ਬਾਅਦ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਨਤੀਜੇ ਅਨੁਮਾਨ ਲਗਾਉਣ ਯੋਗ ਨਹੀਂ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਇੱਕ ਸਾਫਟਵੇਅਰ ਸਿਸਟਮ ਦੀ ਸੁਰੱਖਿਆ ਨਾਲ ਸਮਝੌਤਾ ਕਰ ਸਕਦੇ ਹਨ।


If memory is not freed or freed too late, the amount of in-use memory can increase, which is called a space leak.

ਜੇਕਰ ਮੈਮੋਰੀ ਨੂੰ ਖਾਲੀ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਾਂ ਬਹੁਤ ਦੇਰ ਨਾਲ ਖਾਲੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਵਰਤੋਂ ਵਿੱਚ ਮੈਮੋਰੀ ਦੀ ਮਾਤਰਾ ਵੱਧ ਸਕਦੀ ਹੈ, ਜਿਸਨੂੰ ਸਪੇਸ ਲੀਕ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


The available memory can over time be split into a large number of small blocks.

ਉਪਲਬਧ ਮੈਮੋਰੀ ਸਮੇਂ ਦੇ ਨਾਲ ਛੋਟੇ ਬਲਾਕਾਂ ਦੀ ਇੱਕ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਵੰਡੀ ਜਾ ਸਕਦੀ ਹੈ।


ਕੰਪਾਈਲਰ ਸ਼ਬਦ-ਜੋੜ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ।


Lexical analysis is a crucial step in compilation.

ਸ਼ਬਦ-ਜੋੜ ਵਿਸ਼ਲੇਸ਼ਣ ਕੰਪਾਈਲੇਸ਼ਨ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ।


The lexer generates tokens from the source code.

ਲੈਕਸਰ ਸਰੋਤ ਕੋਡ ਤੋਂ ਟੋਕਨ ਤਿਆਰ ਕਰਦਾ ਹੈ।


ਸਿੰਟੈਕਸ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਇੱਕ ਪਾਰਸਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The grammar defines the structure of the language.

ਵਿਆਕਰਣ ਭਾਸ਼ਾ ਦੀ ਬਣਤਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।


Context-free grammars are widely used in compiler design.

ਕੰਟੈਕਸਟ-ਫ੍ਰੀ ਵਿਆਕਰਣ ਦੀ ਵਰਤੋਂ ਕੰਪਾਈਲਰ ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The compiler optimizes the code for better performance.

ਕੰਪਾਈਲਰ ਬਿਹਤਰ ਪ੍ਰਦਰਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦਾ ਹੈ।


Intermediate code is generated during compilation.

ਕੰਪਾਈਲੇਸ਼ਨ ਦੌਰਾਨ ਵਿਚਕਾਰਲਾ ਕੋਡ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The symbol table stores information about variables.

ਪ੍ਰਤੀਕ ਸਾਰਣੀ ਵੇਰੀਏਬਲਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸਟੋਰ ਕਰਦੀ ਹੈ।


Type checking ensures the correctness of the program.

ਟਾਈਪ ਚੈਕਿੰਗ ਪ੍ਰੋਗਰਾਮ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀ ਹੈ।


The front-end of the compiler handles lexical analysis and parsing.

ਕੰਪਾਈਲਰ ਦਾ ਫਰੰਟ-ਐਂਡ ਸ਼ਬਦ-ਜੋੜ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਪਾਰਸਿੰਗ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।


ਬੈਕ-ਐਂਡ ਮਸ਼ੀਨ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।


Optimization techniques improve code efficiency.

ਅਨੁਕੂਲਨ ਤਕਨੀਕਾਂ ਕੋਡ ਦੀ ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੀਆਂ ਹਨ।


The compiler translates high-level code into machine code.

ਕੰਪਾਈਲਰ ਉੱਚ-ਪੱਧਰੀ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨ ਕੋਡ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ।


Error handling is an important aspect of compilation.

ਗਲਤੀ ਪ੍ਰਬੰਧਨ ਕੰਪਾਈਲੇਸ਼ਨ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪਹਿਲੂ ਹੈ।


The compiler uses various algorithms for optimization.

ਕੰਪਾਈਲਰ ਅਨੁਕੂਲਨ ਲਈ ਵੱਖ-ਵੱਖ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Understanding compiler design is crucial for software developers.

ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਰਾਂ ਲਈ ਕੰਪਾਈਲਰ ਡਿਜ਼ਾਈਨ ਨੂੰ ਸਮਝਣਾ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ।


The compilation process involves several phases.

ਕੰਪਾਈਲੇਸ਼ਨ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਕਈ ਪੜਾਅ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ।


ਕੰਪਾਈਲਰ ਕੁਸ਼ਲ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ।


ਕੰਪਾਈਲਰਾਂ ਦਾ ਅਧਿਐਨ ਦਿਲਚਸਪ ਹੈ।


The compiler translates code into machine instructions.

ਕੰਪਾਈਲਰ ਕੋਡ ਨੂੰ ਮਸ਼ੀਨੀ ਨਿਰਦੇਸ਼ਾਂ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ।


Bootstrapping is a crucial process in compiler design.

ਕੰਪਾਈਲਰ ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਬੂਟਸਟ੍ਰੈਪਿੰਗ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਕਿਰਿਆ ਹੈ।


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

QAD ਕੰਪਾਈਲਰ ਨਵੀਂ ਭਾਸ਼ਾ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।


ਅਸੀਂ ML ਵਿੱਚ ਇੱਕ QAD ਇੰਟਰਪ੍ਰੇਟਰ ਲਿਖ ਸਕਦੇ ਹਾਂ।


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

ਪਹਿਲਾ ਕਦਮ ਇਸਨੂੰ ਕੰਪਾਇਲ ਕਰਨਾ ਹੈ, ਤਾਂ ਜੋ ਇਹ ਕਿਸੇ ਮਸ਼ੀਨ 'ਤੇ ਚੱਲ ਸਕੇ।


The result is a compiler with the desired functionality.

ਨਤੀਜਾ ਲੋੜੀਂਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਵਾਲਾ ਇੱਕ ਕੰਪਾਈਲਰ ਹੈ।


This yields a compiler with the same functionality.

ਇਹ ਉਸੇ ਕਾਰਜਸ਼ੀਲਤਾ ਵਾਲਾ ਇੱਕ ਕੰਪਾਈਲਰ ਦਿੰਦਾ ਹੈ।


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

ਬੂਟਸਟ੍ਰੈਪਿੰਗ ਪੂਰਾ ਨਹੀਂ ਹੋ ਸਕਦਾ ਭਾਵੇਂ ਸਹੀ ਕਾਰਜਸ਼ੀਲਤਾ ਵਾਲਾ ਇੱਕ ਕੰਪਾਈਲਰ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਹੋਵੇ।


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 compiler must be bootstrapped in one of the ways described earlier.

ਪਹਿਲੇ ਕੰਪਾਈਲਰ ਨੂੰ ਪਹਿਲਾਂ ਦੱਸੇ ਗਏ ਤਰੀਕਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਬੂਟਸਟ੍ਰੈਪ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।


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.

ਪਹਿਲਾ ਪਾਸਕਲ ਕੰਪਾਈਲਰ ਵਾਧੇ ਵਾਲੇ ਬੂਟਸਟ੍ਰੈਪਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਇਆ ਗਿਆ ਸੀ।


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

ਇਸ ਪਹੁੰਚ ਦਾ ਫਾਇਦਾ ਇਹ ਹੈ ਕਿ ਇੱਕ ਸਿੰਗਲ ਬਾਈਨਰੀ ਅਨੁਵਾਦਕ ਕਿਸੇ ਵੀ ਗਿਣਤੀ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਪੋਰਟ ਕਰ ਸਕਦਾ ਹੈ।


You have a machine that can execute Alpha machine code.

ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਮਸ਼ੀਨ ਹੈ ਜੋ ਅਲਫ਼ਾ ਮਸ਼ੀਨ ਕੋਡ ਨੂੰ ਚਲਾ ਸਕਦੀ ਹੈ।


Describe the above programs and machine as diagrams.

ਉਪਰੋਕਤ ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਮਸ਼ੀਨ ਨੂੰ ਡਾਇਗ੍ਰਾਮ ਵਜੋਂ ਵਰਣਨ ਕਰੋ।


Show how a compiler from ML to C written in Alphamachine code can be generated.

ਦਿਖਾਓ ਕਿ ਅਲਫ਼ਾਮਸ਼ੀਨ ਕੋਡ ਵਿੱਚ ਲਿਖੇ ML ਤੋਂ C ਤੱਕ ਇੱਕ ਕੰਪਾਈਲਰ ਨੂੰ ਕਿਵੇਂ ਤਿਆਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


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

ਇੱਕ ਸੋਰਸ-ਕੋਡ ਔਪਟੀਮਾਈਜ਼ਰ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਸੋਰਸ-ਕੋਡ ਪੱਧਰ 'ਤੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾ ਸਕਦਾ ਹੈ।


Assume that you additionally have the following components.

ਮੰਨ ਲਓ ਕਿ ਤੁਹਾਡੇ ਕੋਲ ਵਾਧੂ ਤੌਰ 'ਤੇ ਹੇਠ ਲਿਖੇ ਭਾਗ ਹਨ।