Compiler Test: 55 MCQs, 1 Hour, 60% Pass! GATE/NET/DRDO/ISRO

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

As a notable result in formal language studies, we find that:

(1) It is impossible to find a solution to the recognition problem for any Type-0 grammar.

(2) What this means is that there is no finite-time algorithm that can take in an arbitrary string and an arbitrary Type-0 grammar and return whether or not the grammar can produce the string in finite time.

(3) Recognizers that support some subset of Type-0 grammars can be built using a specific technique/method.

(4) Unfortunately, not all Type-0 grammars are compatible with this specific technique/method.

(5) Unfortunately, no matter how many methods we assemble, there will always be Type-0 grammars for which specific technique/method are unsuccessful.

(6) In the case of grammars of Type-1, the situation is entirely different.

(7) In general, it is not always possible to build a parser for a Type-0 grammar, whereas for a Type-1 grammar, it is always possible to do so.

(8) It is an extremely challenging topic to build a practical and relatively efficient parser for such grammars, but over the past 25 years, researchers have made steady progress.

(9) This is due to the fact that Type-0 and Type-1 grammars are well-known to be un-friendly to humans and thus will never see wide applications; hence it is not a very popular research area.

(10) However, it is not completely useless because a good parser for Type 0 grammars would definitely make a suitable starting point for a theorem prover/verifier. This means that it does have some useful uses.

(11) For Type-0 and Type-1 grammars, all existing parsing methods have exponential time dependency.

Summarized Explanation:

Correct option is (c).

The first statement is incorrect.

It has been determined that the item in question is a SHIFT item.

Statement2 is correct.

In point of fact, a top-down parser will begin the process of generating the top node of the tree by using the start symbol. It will then construct the nodes of the abstract syntax tree in pre-order, whereas a bottom-up parser will construct the nodes of the abstract syntax tree in post-order.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

It is possible to briefly outline the key differences between LL(1) and LALR(1) as follows:

(1) More extensive grammatical changes are typically needed for LL(1) than LALR (1).

(2) In contrast to LALR(1), which only executes semantic actions at the end of an alternative, LL(1) permits them to be executed at any time prior to the beginning of an alternative.

(3) It is possible for the semantic actions in an LL(1) parser implemented as a recursive-descent parser to make use of named variables and attributes, just as they would in a programming language. In a parser that uses tables, such an application is impossible.

(4) In terms of speed and memory needs, the two approaches are basically similar; but, a well-implemented approach will always outperform a poor one.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

The provided statement is, in fact, a part of the foundational definition of CFG.

Statement2 is correct.

Examine the grammar.

S -> a | B

A -> Bb | ε

Any non-terminal symbol 'R' is said to be left-recursive in terms of context-free grammar if the left-most symbol in any of R's productions rewrites to 'R' again, either directly (immediate left-recursive) or through some other non-terminal definitions (indirect/hidden left-recursive).

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Explanation: The following is an explanation for Statement1 given in MCQ.

Compare the following compiler and interpreter inputs and their resulting outputs.

a = 12;

b = 6;

c = a+b;

println (c, a, b);

Here are the results from the compiler and the interpreter.

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

In an infinite language, the length of any string is not limited. There is no limit on how many steps can be used to find the strings. For example, if the grammar has n productions, then any derivation with n + 1 steps uses some production twice. If the language is said to be infinite, then some production or sequence of productions must be used over and over to make the derivations.

For example:

The infinite language {anb | n > 0} is described by the grammar,

X -> b | aX.

To derive the string anb, use the production X -> aX repeatedly n times and then stop the derivation by using the production X -> b.

The production X -> aX allows us to say: “If X derives p, then it derives ap also”.

Build grammar:

There is no one strategy that can be applied universally to the task of discovering a grammar for an infinite language. Yet, the strategy of integrating several grammars can be helpful.

Here's an example: think about the following question:

Find a grammar for the following language: {ɛ, a, aa, . . . , an, . . . } = {an: n ∈ N}

Solution:

The set of terminals: T = {a},

The only non-terminal start symbol X,

The set of production rules: X -> ɛ, X -> aX

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

We were aware that there are two different approaches to parsing, top-down and bottom-up. Apart from that, we may additionally classify parsing methods as either non-directed or directional.

A non-directional technique builds the parse tree while accessing the input in any order it sees fit. Because of this, the full input needs to be stored in memory before the parsing process can begin. Both a top-down and a bottom-up approach are available here.

The top-down, non-directional approach is easy to understand and use. This was first described by Unger. This technique will henceforth be known as the Unger approach. Several people, including Cocke, Younger, and Kasami, have separately come across the non-directional bottom-up approach. In honor of the three most prominent creators, it is known as CYK (or CKY). Since its simple implementation is far more efficient than Unger's, it has garnered a lot of attention.

The input is read and interpreted from left to right by the directional methods. (Parsing can alternatively be done from right to left using a mirror version of the grammar, which can be helpful in some cases.) Because of this, parsing can get started and make significant progress far before the final symbol of the input is visible. Top-down approaches do predictions and matches, while bottom-up methods perform shifts and reduce; both are dependent on the parsing automata, either directly or indirectly.

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

There is only one linear top-down method, called LL. The first L stands for "Left to right," and the second L stands for "identifying the left-most production," which is what directional top-down parsers do. People use LL parsing a lot, especially LL(1). Most LL(1) parsers are made by a "parser generator," but a simple one can be written by hand using recursive-descent techniques with a little work. Sometimes, the LL(1) method is used backwards, beginning with the last token of the input. This is called RR(1).

Summarized Explanation:

Correct option is (a).

Both of these statements are correct since they provide us the fundamental definitions.

Summarized Explanation:

Correct option is (c).

Statement1 is untrue.

The LEX system is a generator for lexical analyzers. If an LEX source file is provided, which contains regular expressions for a variety of tokens, LEX will generate a lexical analyzer (based on a DFA) that is written in C. This lexical analyzer will group characters that match the expressions into lexemes, and it will be able to return the tokens that correspond to those lexemes.

Statement2 is true.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Explanation: The following is a summarized explanation for Statement1 of given MCQ.

As a notable result in formal language studies, we find that:

(1) It is impossible to find a solution to the recognition problem for any Type-0 grammar.

(2) What this means is that there is no finite-time algorithm that can take in an arbitrary string and an arbitrary Type-0 grammar and return whether or not the grammar can produce the string in finite time.

(3) Recognizers that support some subset of Type-0 grammars can be built using a specific technique/method.

(4) Unfortunately, not all Type-0 grammars are compatible with this specific technique/method.

(5) Unfortunately, no matter how many methods we assemble, there will always be Type-0 grammars for which specific technique/method are unsuccessful.

(6) In the case of grammars of Type-1, the situation is entirely different.

(7) In general, it is not always possible to build a parser for a Type-0 grammar, whereas for a Type-1 grammar, it is always possible to do so.

(8) It is an extremely challenging topic to build a practical and relatively efficient parser for such grammars, but over the past 25 years, researchers have made steady progress.

(9) This is due to the fact that Type-0 and Type-1 grammars are well-known to be un-friendly to humans and thus will never see wide applications; hence it is not a very popular research area.

(10) However, it is not completely useless because a good parser for Type 0 grammars would definitely make a suitable starting point for a theorem prover/verifier. This means that it does have some useful uses.

(11) For Type-0 and Type-1 grammars, all existing parsing methods have exponential time dependency.

(12) The good news is that parsing algorithms for Context Free (Type 2) grammars are much more developed than those for Type-0 and Type-1 grammars.

(13) Context-free and regular (finite state) grammars are used for almost all practical parsing, and almost all problems with context-free parsing have been solved.

(14) The locality of the Context Free production process is the root cause of this major difference. The development of one non-terminal in the sentential form is totally independent of the development of any other non-terminal, and vice versa, when we are parsing, we are able to combine partial parse trees regardless of their histories.

(15) In a context-sensitive (Type-1) grammar, neither of those things is true.

Statement2 is correct.

Explanation: The following is a summarized explanation for Statement2 of given MCQ.

Top down parser construct parse tree from root (start symbol) toward leaves (tokens);

Bottom up parser construct parse tree from leaves to root;

Both Top down and Bottom up parsers scan the input stream from left to right;

LL parsers (Left to right scan; Left most parsing) usually Top down, prediction, hand coded;

LR parser (Left to right scan; Right most parsing) usually Bottom up, automated generation.

The parse tree, which explains how the grammar was applied in order to construct the sentence, is the fundamental relationship that exists between a sentence and the grammar that it derives from. In order to put back together this connection, we will need to use a parsing strategy.

The first way is an attempt to recreate the production process that was used initially by recalculating the sentence based on the start symbol. This strategy is referred regarded as top-down, as the production tree is reconstructed beginning at the very top and working its way down.

The second method works to reverse the creation process and bring the sentence back to its initial form, which is known as the start symbol. The term for this methodology is "bottom-up."

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Think about the following steps as possible answers or clarifications.

Step1: Factor (and remove) all common prefixes.

Only production A has a common prefix; it is ‘ab’.

We can replace productions 2 and 3 by the single production A -> abC, introducing new non-terminal C.

C will have two productions: C -> cDE and C -> E.

Step2: Remove all left recursion.

Only production 4 has left recursion. We will replace production 4 with D -> XY.

X will take over all other productions of D, so we add production X -> e corresponding to original production 5.

Y will provide a right-recursive rule for production 4, Y -> dY.

Step3: Final grammar is as under.

(1) S -> A$

(2) A -> abC

(3) C -> cDE

(4) | E

(5) D -> XY

(6) X -> e

(7) Y -> dY

(8) | ɛ

(9) E -> f

Statement2 is correct.

S => aS => aSb => acb

S => Sb => aSb => acb

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Statement2 is correct.

Summarized Explanation:

Correct option is (a).

Both of these statements are correct since they provide us the fundamental definitions.

Summarized Explanation:

Correct option is (a).

Statement 1 is correct.

Consider the following grammar.

S -> Aa | Bb

A -> PQ | a

B -> PQ | b

The corresponding LR(0) set of items will be:

Item set 0:

S' -> .S

S  -> .Aa | .Bb

A -> .PQ | .a

B -> .PQ | .b

Item set 1:

S' -> S.

Item set 2:

S  -> A.a

Item set 3:

S -> B.b

Item set 4:

A -> P.Q

B -> P.Q

Item set 5:

A -> a.

Item set 6:

B -> b.

The second statement (Statement2) is correct.

When there is a conflict, YACC will perform some sort of default action. The YACC will shift for shift-reduce conflicts. It will use the first rule in the listing whenever there is a reduce-reduce conflict. Additionally, it sends out a warning message every time there is a conflict. By removing any possible opportunity for interpretation from the grammar, the warnings can be removed.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

Explanation: The following is an explanation for Statement1 given in MCQ.

Analyze the provided grammar.

S -> AB

A -> ε | aA

B -> b | bb

Statement2 is incorrect.

Explanation: The following is an explanation for Statement2 given in MCQ.

It is possible for the look-ahead set that is associated with an LR(1) item to have more than one member. For instance, "A -> a.Bb, {a / b / c}" are all examples of this.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

Examine the grammar.

S -> A | xb

A -> aAb | x

It uses the following argument grammar.

S' -> S

S -> A

S -> xb

A -> aAb

A -> x

Item set 0 is as under.

S' -> .S

S -> .A

S -> .xb

A -> .aAb

A -> .x

Symbols after dot are: S, A, x, and a

For non-terminal ‘S’ of item set 0, we have item set 1, as under.

S' -> S.

For non-terminal ‘A’ of item set 0, we have item set 2, as under.

S -> A.

For terminal ‘x’ of item set 0, we have item set 3, as under.

S -> x.b

A -> x.

For terminal ‘a’ of item set 0, we have item set 4, as under.

A -> a.Ab

A -> .aAb

A -> .x

For terminal ‘b’ of item set 3, we have item set 5, as under.

S -> xb.

For non-terminal ‘A’ of item set 4, we have item set 6, as under.

A -> aA.b

Note that terminal ‘a’ of item set 4 is already processed in item set 4 itself. Also the terminal ‘x’ of item set 4 is already processed in item set 3.

For terminal ‘b’ of item set 6, we have item set 7, as under.

A -> aAb.

The ACTION/GOTO table is as under.

Due to multiple entry, given grammar is not LR(0) due to shift-reduce conflict, but there is no any reduce-reduce conflict.

Statement2 is incorrect.

Summarized Explanation:

The correct answer is (a).

Statement1 is correct.

As a matter of fact, the given statement is the essential step of SLR(1) parsing, which differentiates distinct from LR(0) parsing and makes it more powerful than LR(0) parsing.

It's correct to say that Statement2 is correct.

Substituting one production for another can help us to remove FIRST/FOLLOW and indirect conflicts, but it can also create FIRST/FIRST conflicts in some cases.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

Explanation: The following is an explanation for Statement1 given in MCQ.

An interpreter, which is not the same as a compiler, is another way to get code to run on a processor. An interpreter translates code like a compiler does, but it reads the code and runs it immediately, so it is faster than a compiler at first. Since interpreters can run one line of code at a time, they are often used as tools for debugging when making software. The compiler changes all of the code at once, and then the processor runs the machine language that the compiler made. If changes are made to the code after it has been compiled, the new code must be compiled and added to the code that has already been compiled (or perhaps the entire program will need to be re-compiled.) But a program that hasn't been fully compiled runs much faster with a compiler than with an interpreter, even though the interpreter skips the step of compiling the whole program at the beginning.

Interpreters, on the other hand, are useful for things like debugging and training, where speed isn't as important. It's also possible to take the whole interpreter and use it on another ISA, which makes it more portable than a compiler when switching between hardware architectures. There are different kinds of interpreters, such as the syntax-directed interpreter (also called the Abstract Syntax Tree (AST) interpreter), the bytecode interpreter, the threaded interpreter (not to be confused with concurrent processing threads), the Just-in-Time interpreter/compiler, and a few others. Python, Ruby, Perl, and PHP are all kinds of programming languages that use interpreters.

Statement2 is incorrect.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

We were aware that there are two different approaches to parsing, top-down and bottom-up. Apart from that, we may additionally classify parsing methods as either non-directed or directional.

A non-directional technique builds the parse tree while accessing the input in any order it sees fit. Because of this, the full input needs to be stored in memory before the parsing process can begin. Both a top-down and a bottom-up approach are available here.

The top-down, non-directional approach is easy to understand and use. This was first described by Unger. This technique will henceforth be known as the Unger approach. Several people, including Cocke, Younger, and Kasami, have separately come across the non-directional bottom-up approach. In honor of the three most prominent creators, it is known as CYK (or CKY). Since its simple implementation is far more efficient than Unger's, it has garnered a lot of attention.

The input is read and interpreted from left to right by the directional methods. (Parsing can alternatively be done from right to left using a mirror version of the grammar, which can be helpful in some cases.) Because of this, parsing can get started and make significant progress far before the final symbol of the input is visible. Top-down approaches do predictions and matches, while bottom-up methods perform shifts and reduce; both are dependent on the parsing automata, either directly or indirectly.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect about Recursive Descent Parser.

Statement2 is incorrect about stack belongs to bottom-up parser.

Summarized Explanation:

Correct option is (a).

Both of these statements are correct since they provide us the fundamental definitions.

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Examine the grammar.

S -> A | x

A -> aAb | x

It uses the following argument grammar.

S' -> S

S -> A

S -> x

A -> aAb

A -> x

Item set 0 is as under.

S' -> .S

S -> .A

S -> .x

A -> .aAb

A -> .x

Symbols in the right of dot are: S, A, x, a

For non-terminal S of item set 0 we have item set 1 as under.

S' -> S.

For non-terminal A of item set 0 we have item set 2 as under.

S -> A.

For terminal x of item set 0 we have item set 3 as under.

S -> x.

A -> x.

For terminal a of item set 0 we have item set 4 as under.

A -> a.Ab

A -> .aAb

A -> .x

Symbols in the right of dot are: A, a, x.

For non-terminal A of item set 4 we have item set 5 as under.

A -> aA.b

Note that for terminal a of item set 4 we already processed it in item set 4 itself; and for terminal x of item set 4, we already processed it in item set 3.

For terminal b of item set 5, we have item set 6 as under.

A -> aAb.

The ACTION/GOTO table is as under.

Due to multiple entry, given grammar is not LR(0).

Statement2 is correct.

Given grammar is ambiguous.

Summarized Explanation:

Correct option is (b).

Statement1 is correct.

Statement2 is incorrect.

Important fact:

It is important to note that top-down methods are more effective than bottom-up methods for regular (Type-3) grammars; however, if a regular grammar only has productions of the form A -> a and A -> Ba (and no others), then the bottom-up method is more effective than the top-down method.

Now think about the grammar that's been provided.

S -> Aa | b | bB

A -> a

B -> b

Since this regular grammar have productions of the form A -> a and A -> Ba but there is also a production S -> bB, which is other than the given two forms of production, thus top-down parsing works better for it.

Thus, Statement1 is correct and Statement2 is incorrect.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

The problems caused by FIRST/FOLLOW are solved through substitution.

Statement2 is incorrect.

In addition, the process of left-factoring is required when given grammar is used.

Summarized Explanation:

Correct option is (a).

Both of these statements are correct since they provide us the fundamental definitions.

Summarized Explanation:

Correct option is (b).

Statement1 is correct.

LALR(1) grammars are handled by the YACC parser generator.

Statement2 is incorrect.

Actually, the shift operation is what's used to resolve these kinds of conflicts by default.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

We were aware that there are two different approaches to parsing, top-down and bottom-up. Apart from that, we may additionally classify parsing methods as either non-directed or directional.

A non-directional technique builds the parse tree while accessing the input in any order it sees fit. Because of this, the full input needs to be stored in memory before the parsing process can begin. Both a top-down and a bottom-up approach are available here.

The top-down, non-directional approach is easy to understand and use. This was first described by Unger. This technique will henceforth be known as the Unger approach. Several people, including Cocke, Younger, and Kasami, have separately come across the non-directional bottom-up approach. In honor of the three most prominent creators, it is known as CYK (or CKY). Since its simple implementation is far more efficient than Unger's, it has garnered a lot of attention.

The input is read and interpreted from left to right by the directional methods. (Parsing can alternatively be done from right to left using a mirror version of the grammar, which can be helpful in some cases.) Because of this, parsing can get started and make significant progress far before the final symbol of the input is visible. Top-down approaches do predictions and matches, while bottom-up methods perform shifts and reduce; both are dependent on the parsing automata, either directly or indirectly.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

In the event when more than one lexeme is capable of matching a pattern, the lexical analyzer is required to supply the subsequent compiler stages with additional information regarding the specific lexeme that was successful. For instance, the pattern for token number can match either 0 or 1, but it is critical for the code generator to be aware of which lexeme was discovered in the source program. Therefore, the lexical analyzer returns to the parser, in many instances, not only a token name, but also an attribute value that describes the lexeme that is represented by the token. The token name influences decisions made during parsing, while the attribute value influences translation of tokens after the parse has been completed.

Statement2 is incorrect.

The regular description serves as the driving force behind the generator.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Question: Exponential time dependence means what?

If the amount of time needed to process each successive input symbol increases by a constant factor, say 3, then the time dependency is exponential. In the notation for exponential time dependence, O(Cⁿ), C being the constant multiplier, represents the exponential function.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

As a notable result in formal language studies, we find that:

(1) It is impossible to find a solution to the recognition problem for any Type-0 grammar.

(2) What this means is that there is no finite-time algorithm that can take in an arbitrary string and an arbitrary Type-0 grammar and return whether or not the grammar can produce the string in finite time.

(3) Recognizers that support some subset of Type-0 grammars can be built using a specific technique/method.

(4) Unfortunately, not all Type-0 grammars are compatible with this specific technique/method.

(5) Unfortunately, no matter how many methods we assemble, there will always be Type-0 grammars for which specific technique/method are unsuccessful.

(6) In the case of grammars of Type-1, the situation is entirely different.

(7) In general, it is not always possible to build a parser for a Type-0 grammar, whereas for a Type-1 grammar, it is always possible to do so.

(8) It is an extremely challenging topic to build a practical and relatively efficient parser for such grammars, but over the past 25 years, researchers have made steady progress.

(9) This is due to the fact that Type-0 and Type-1 grammars are well-known to be un-friendly to humans and thus will never see wide applications; hence it is not a very popular research area.

(10) However, it is not completely useless because a good parser for Type 0 grammars would definitely make a suitable starting point for a theorem prover/verifier. This means that it does have some useful uses.

(11) For Type-0 and Type-1 grammars, all existing parsing methods have exponential time dependency.

(12) The good news is that parsing algorithms for Context Free (Type 2) grammars are much more developed than those for Type-0 and Type-1 grammars.

(13) Context-free and regular (finite state) grammars are used for almost all practical parsing, and almost all problems with context-free parsing have been solved.

(14) The locality of the Context Free production process is the root cause of this major difference. The development of one non-terminal in the sentential form is totally independent of the development of any other non-terminal, and vice versa, when we are parsing, we are able to combine partial parse trees regardless of their histories.

(15) In a context-sensitive (Type-1) grammar, neither of those things is true.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

The nodes in an Abstract Syntax Tree (AST) are generated by a bottom-up parser in the post-order, while the nodes in an AST are generated by a top-down parser in the pre-order.

Statement2 is correct about SLR(1) parser.

Summarized Explanation:

Correct option is (c).

Statement1 is wrong.

To be more precise, in formal languages, Context Free Grammar (CFG) is a grammar that produces a formal language in which clauses can be nested inside clauses but grammatical structures are not allowed to overlap.

Statement2 is accurate.

A stream of characters is changed into a stream of tokens when run through a lexical analyzer.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

There is only one linear top-down method, called LL. The first L stands for "Left to right," and the second L stands for "identifying the left-most production," which is what directional top-down parsers do. People use LL parsing a lot, especially LL(1). Most LL(1) parsers are made by a "parser generator," but a simple one can be written by hand using recursive-descent techniques with a little work. Sometimes, the LL(1) method is used backwards, beginning with the last token of the input. This is called RR(1).

Summarized Explanation:

Correct option is (b).

Statement1 is correct.

When LLgen parse detects an error after having parsed the string s, the default choices enable it to compute one syntactically correct continuation, consisting of the tokens t₁ . . . t_n, such that s t₁ . . . t_n is a string of tokens that is a member of the language defined by the grammar. Notice, that the computation of this continuation must terminate, which implies that the default choices may not invoke recursive rules.

Statement2 is un-true.

The information contained in the symbol table is utilized by both the analysis and synthesis phases:

(1) To check if the IDs that are being used have been defined (declared)

(2) To ensure that the expressions and assignments are correct from a semantic viewpoint (type checking)

(3) In order to generate either the intermediate or the target code

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

FIRST(S) contains 3 elements.

Examine the grammar.

S -> AB

A -> ε | aA

B -> ε | bB

Thus, FIRST(S) contains 3 elements.

Statement2 is incorrect.

Terminals: {x, y, z, $}

Non-terminals: {S, A, B}

FIRST(S) = {x, y, z}

FIRST(A) = {x, y, z}

FIRST(B) = {y, z}

FOLLOW(S) = {}

FOLLOW(A) = {y, z}

FOLLOW(B) = {y, z, $}

PREDICT(production-1) = {x, y, z}

PREDICT(production-2) = {x}

PREDICT(production-3) = {y, z}

PREDICT(production-4) = {y}

PREDICT(production-5) = {z}

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

An interpreter, which is not the same as a compiler, is another way to get code to run on a processor. An interpreter translates code like a compiler does, but it reads the code and runs it immediately, so it is faster than a compiler at first. Since interpreters can run one line of code at a time, they are often used as tools for debugging when making software. The compiler changes all of the code at once, and then the processor runs the machine language that the compiler made. If changes are made to the code after it has been compiled, the new code must be compiled and added to the code that has already been compiled (or perhaps the entire program will need to be re-compiled.) But a program that hasn't been fully compiled runs much faster with a compiler than with an interpreter, even though the interpreter skips the step of compiling the whole program at the beginning.

Interpreters, on the other hand, are useful for things like debugging and training, where speed isn't as important. It's also possible to take the whole interpreter and use it on another ISA, which makes it more portable than a compiler when switching between hardware architectures. There are different kinds of interpreters, such as the syntax-directed interpreter (also called the Abstract Syntax Tree (AST) interpreter), the bytecode interpreter, the threaded interpreter (not to be confused with concurrent processing threads), the Just-in-Time interpreter/compiler, and a few others. Python, Ruby, Perl, and PHP are all kinds of programming languages that use interpreters.

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

Compilers take code written in a high-level language and turn it into code that a computer can understand. Compilers can take a long time because they have to translate high-level code into lower-level machine language all at once and then store the executable object code in memory. A compiler makes machine code that runs on a processor with a specific Instruction Set Architecture (ISA), which is different for each processor. For example, without a special compiler, we can't compile code for an x86 and run it on a MIPS. Compilers also depend on the platform. That is, a compiler can turn, say, C++ into machine code for a platform that runs the Linux operating system. A cross-compiler, on the other hand, can make code for a different platform than the one it runs on.

An interpreter, which is not the same as a compiler, is another way to get code to run on a processor. An interpreter translates code like a compiler does, but it reads the code and runs it immediately.

Summarized Explanation:

Correct option is (b).

Statement1 is correct.

To put it simply, a predicate parser is a top-down parser.

Statement2 is incorrect.

When a grammar has left recursive non-terminal, a top-down parser will not be able to process it.

Summarized Explanation:

Correct option is (a).

Statement 1 is correct.

FIRST(S) contains 3 elements.

Take the provided grammar into consideration.

S -> AB

A -> ε | aA

B -> ε | bB

Thus, FIRST(S) contains 3 elements.

Statement2 is correct.

Left-factoring takes care of FIRST/FIRST conflict.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

We were aware that there are two different approaches to parsing, top-down and bottom-up. Apart from that, we may additionally classify parsing methods as either non-directed or directional.

A non-directional technique builds the parse tree while accessing the input in any order it sees fit. Because of this, the full input needs to be stored in memory before the parsing process can begin. Both a top-down and a bottom-up approach are available here.

The top-down, non-directional approach is easy to understand and use. This was first described by Unger. This technique will henceforth be known as the Unger approach. Several people, including Cocke, Younger, and Kasami, have separately come across the non-directional bottom-up approach. In honor of the three most prominent creators, it is known as CYK (or CKY). Since its simple implementation is far more efficient than Unger's, it has garnered a lot of attention.

The input is read and interpreted from left to right by the directional methods. (Parsing can alternatively be done from right to left using a mirror version of the grammar, which can be helpful in some cases.) Because of this, parsing can get started and make significant progress far before the final symbol of the input is visible. Top-down approaches do predictions and matches, while bottom-up methods perform shifts and reduce; both are dependent on the parsing automata, either directly or indirectly.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

There are quite a few different linear bottom-up approaches, the most effective of which is referred to as LR. In this method, the letters L stand for left-to-right and the letters R stand for "identifying the right-most production." These parsers are generally produced by a parser generator since the control mechanism of such a parser is so complex that it is not practical for a human to manually design it. Several of the linear bottom-up approaches are extremely common, and it's possible that they're utilized in even more situations than the LL(1) method is. The LR(1) parsing method is more effective than the LL(1) parsing method; but, it is also more difficult to understand and less convenient. In contrast to the LL(1) method, the other approaches are more difficult to evaluate. The LR(1) approach can also be applied in reverse, in which case it is referred to as the RL(1) method.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

As a notable result in formal language studies, we find that:

(1) It is impossible to find a solution to the recognition problem for any Type-0 grammar.

(2) What this means is that there is no finite-time algorithm that can take in an arbitrary string and an arbitrary Type-0 grammar and return whether or not the grammar can produce the string in finite time.

(3) Recognizers that support some subset of Type-0 grammars can be built using a specific technique/method.

(4) Unfortunately, not all Type-0 grammars are compatible with this specific technique/method.

(5) Unfortunately, no matter how many methods we assemble, there will always be Type-0 grammars for which specific technique/method are unsuccessful.

(6) In the case of grammars of Type-1, the situation is entirely different.

(7) In general, it is not always possible to build a parser for a Type-0 grammar, whereas for a Type-1 grammar, it is always possible to do so.

(8) It is an extremely challenging topic to build a practical and relatively efficient parser for such grammars, but over the past 25 years, researchers have made steady progress.

(9) This is due to the fact that Type-0 and Type-1 grammars are well-known to be un-friendly to humans and thus will never see wide applications; hence it is not a very popular research area.

(10) However, it is not completely useless because a good parser for Type 0 grammars would definitely make a suitable starting point for a theorem prover/verifier. This means that it does have some useful uses.

(11) For Type-0 and Type-1 grammars, all existing parsing methods have exponential time dependency.

Summarized Explanation:

Correct option is (b).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

Because it is in the form A ->.w the item that is being given serves as a SHIFT item.

Statement2 is incorrect.

Explanation: The following is an explanation for Statement2 given in MCQ.

The letters LR form an acronym of their own.

The letter L indicates that the parser reads the input text in a single direction without performing any backtracking; typically, this direction is left to right inside each line and top to bottom across the lines of the entire input file. This is the case for the majority of parsers.

A bottom-up parse is performed by the parser, as opposed to a top-down LL parse or an ad-hoc parse. The R indicates that the parser generates a reversed rightmost derivation.

The name LR is frequently followed by a numeric qualifier, such as LR(1) or even LR(k), depending on the context of k.

Before determining how to parse previous symbols, the LR parser is given permission to take a sneak peek at k LOOKAHEAD input symbols. This is done to prevent the need for backtracking or guesswork.

In most cases, k is equal to 1, and it is not mentioned. The initials LR are frequently followed by a variety of prefixes and suffixes, such as SLR and LALR.

Summarized Explanation:

Correct option is (a).

Both of these statements are correct since they provide us the fundamental definitions.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Important fact:

It is important to note that top-down methods are more effective than bottom-up methods for regular (Type-3) grammars; however, if a regular grammar only has productions of the form A -> a and A -> Ba (and no others), then the bottom-up method is more effective than the top-down method. Thus given Statement1 is correct.

Now think about the grammar that's been provided.

S -> Aa | b | bB

A -> a

B -> b

Since this regular grammar have productions of the form A -> a and A -> Ba but there is also a production S -> bB, which is other than the given two forms of production, thus top-down parsing works better for it.

But if a regular grammar have productions of the form A -> a and A -> Ba only then as per the above given important fact bottom-up parsing method works better than top-down parsing method. Thus, given Statement2 is correct.

Summarized Explanation:

The appropriate option is (c).

Statement1 is false.

In fact, the LLgen parser generator's error handling mechanism pulls the input stream back whenever it inserts a "missing" token.

Statement2 is correct for a parser that uses recursive descent.

Summarized Explanation:

Correct option is (d).

Statement1 is incorrect.

Think about the following counter questions as possible answers or clarifications.

Question1: What kind of grammar is this? LL(1)? If it is not the case, then why not?

To be clear, this is not LL(1) grammar. The PREDICT sets for Productions 2 and 3 are redundant. An 'e' can be found in both, that is, the letter 'e' is shared by both.

The point can be seen to be proven by the two partial derivations that follow:

S -> A$ -> BCD -> DeCD -> eCD

S -> A$ -> EFG -> GeFG -> eFG

Question2: What kind of grammar is this? LL(2)? If it is not the case, then why not?

To be clear, this is not LL(2) grammar. The PREDICT sets for Productions 2 and 3 are redundant. An 'ec' can be found in both.

The point can be seen to be proven by the two partial derivations that follow:

S -> A$ -> BCD -> DeCD -> eCD -> eccD

S -> A$ -> EFG -> GeFG -> eFG -> ecG

Question3: Is this language LL(k) for all k?

Since the longest string in the language is only 5 symbols long, a 5-symbol LOOKAEAD would let us parse by just looking up the symbols in a table. The language is more likely to be LL(3).

Statement2 is incorrect.

It is possible that left-factoring is required.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

A bottom-up parse is the process of constructing a parse tree for an input string by starting at the leaves (which are located at the bottom) and progressively working up towards the root (the top).

Bottom-up parsing can be thought of as the process of reducing the given string w (the sentence) to the start symbol of the grammar. We can think of this process as reducing the length of the sentence. The steps in this method are carried out in the opposite sequence of those that are required for top-down parsing. A sub-string that matches the body of a production, which is the right hand side of a production rule, is reduced to the head of the production rule at each step of the reduction process. The bottom-up parsing process involves a number of important judgments, the most important of which are:

(1) When to reduce the body of a head by corresponding production, and

(2) Which among the matching rules to apply out of the supplied productions as the parsing advances?

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

Challenges posed by top-down and bottom-up methodologies:

(1) Top-Down does not verify if the actual inputs correspond to the predictions that have been created.

(2) Bottom-Up does not conduct any checks to see if the recognized constituents correspond to anything that may be predicted beginning with S.

The following challenges can be overcome with the use of mixed approaches, called “Left Corner Parsing”. This method parses parts of the tree using the top-down approach, and it parses other parts of the tree using the bottom-up approach.

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Explanation: The following is an explanation for Statement1 given in MCQ.

“Simply construct its FSA, and then minimize it to determine the exact number of states that will accept it”.

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

“The basic pattern is taken care of by the character-moves”.

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Explanation: The following is an explanation for Statement1 given in MCQ.

“While LL(1) grammar is manageable for a top-down parser, LR(1) is not”.

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

The parsers that YACC generates are, for all intents and purposes, finite state machines that include a stack. They function by repeatedly inputting and shifting (pushing) symbols until a complete Right-Hand-Side (RHS) of a grammar rule is on the stack, and then reducing (popping) the RHS to the corresponding (pushed) Left-Hand-Side. This process continues until the RHS of the grammar rule is completely represented on the stack (LHS). YACC uses an algorithm known as LR(1) for its parser, and it uses an algorithm known as LALR(1) for the creation of its decision table.

Summarized Explanation:

Correct option is (b).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

“Lexical analyzer should read the complete input program into memory”.

Statement2 is incorrect.

Explanation: The following is an explanation for Statement2 given in MCQ.

The regular expression a⁺|b⁺ represent the language {a, aa, aaa, …}|{b, bb, bbb, …} while the regular expression (a|b)⁺ represent a language in which there can be a string with combination of symbols ‘a’ and ‘b’.

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Examine the grammar.

S -> Aa | Bb

A -> PP | a

B -> QQ | b

It uses the following argument grammar.

S' -> S

S -> Aa

S -> Bb

A -> PP

A -> a

B -> QQ

B -> b

Item set 0 is as under.

S' -> .S

S -> .Aa

S -> .Bb

A -> .PP

A -> .a

B -> .QQ

B -> .b

Symbols in the right of dot are: S, A, B, P, a, Q, b

For non-terminal ‘A’ of Item Set 0, we have Item Set 1, as under.

S -> A.a

For non-terminal ‘B’ of Item Set 0, we have Item Set 2, as under.

S -> B.b

For non-terminal ‘P’ of Item Set 0, we have Item Set 3, as under.

A -> P.P

For terminal ‘a’ of Item Set 0, we have Item Set 4, as under.

A -> a.

For non-terminal ‘Q’ of Item Set 0, we have Item Set 5, as under.

B -> Q.Q

For terminal ‘b’ of Item Set 0, we have Item Set 6, as under.

B -> b.

Now, we do not need to continue the process of constructions of item set, as up to this point it is clear that statement is false.

Regarding the stack of bottom-up parsing, Statement2 is absolutely correct.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Statement2 is correct.

Explanation: The following is a summarized explanation for both of the statements (Statement1 and Statement2) that were given in MCQ.

There are quite a few different linear bottom-up approaches, the most effective of which is referred to as LR. In this method, the letters L stand for left-to-right and the letters R stand for "identifying the right-most production." These parsers are generally produced by a parser generator since the control mechanism of such a parser is so complex that it is not practical for a human to manually design it. Several of the linear bottom-up approaches are extremely common, and it's possible that they're utilized in even more situations than the LL(1) method is. The LR(1) parsing method is more effective than the LL(1) parsing method; but, it is also more difficult to understand and less convenient. In contrast to the LL(1) method, the other approaches are more difficult to evaluate. The LR(1) approach can also be applied in reverse, in which case it is referred to as the RL(1) method.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

Top-down parsers work on the concept that the input is already known, and that the next symbol will either be a terminal symbol (in which case the parser will "MATCH") or a non-terminal symbol (in which case the parser will "PREDICT").

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

When performing bottom-up parsing, the process begins with the input, and from there, an attempt is made to reduce it to the start symbol. Both SHIFT and REDUCE are important words in this context. When we are in the middle of the process, we will have a reduced sentential form in our hands. This form was derived from the input. This sentential form must contain, at some point, a segment (a sub-string) that was the result of the very last production step that produced this sentential form; this segment is the right-hand side of a non-terminal to which it must now be reduced. This segment can be found anywhere in this sentential form. This part of the sentence is referred to as the handle of the sentential form, which is an expression that fits quite well. Finding the handle is going to be difficult. It must be the right-hand side of a rule, so we begin our search for such a right-hand side by moving symbols from the sentential form into the internal administration. This ensures that the right-hand side of the rule is always used.

We will continue this process until only the start symbol is left, at which point we will reduce each right-hand side we find to its corresponding left-hand side. This method will not always lead us to the appropriate handle; if we make a mistake, we will get stuck further on and be forced to backtrack a few steps, shift in additional symbols, and try again.

Summarized Explanation:

Correct option is (a).

Statement1 is correct.

Explanation: The following is an explanation for Statement1 given in MCQ.

“A top-down parser cannot process a left-recursive non-terminal, whereas a bottom-up parser can”.

Statement2 is correct.

Explanation: The following is an explanation for Statement2 given in MCQ.

Take the grammar into account.

S -> A | xb

A -> aAb | x

Its augmented grammar is as under.

S' -> S

S -> A

S -> xb

A -> aAb

A -> x

Item set 0 is as under.

S' -> .S

S -> .A

S -> .xb

A -> .aAb

A -> .x

Symbols after dot are: S, A, x, and a

For non-terminal ‘S’ of item set 0, we have item set 1, as under.

S' -> S.

For non-terminal ‘A’ of item set 0, we have item set 2, as under.

S -> A.

For terminal ‘x’ of item set 0, we have item set 3, as under.

S -> x.b

A -> x.

For terminal ‘a’ of item set 0, we have item set 4, as under.

A -> a.Ab

A -> .aAb

A -> .x

For terminal ‘b’ of item set 3, we have item set 5, as under.

S -> xb.

For non-terminal ‘A’ of item set 4, we have item set 6, as under.

A -> aA.b

Note that terminal ‘a’ of item set 4 is already processed in item set 4 itself. Also the terminal ‘x’ of item set 4 is already processed in item set 3.

For terminal ‘b’ of item set 6, we have item set 7, as under.

A -> aAb.

The ACTION/GOTO table is as under.

Due to multiple entry, given grammar is not LR(0).

Summarized Explanation:

Correct option is (c).

Statement1 is incorrect.

Statement2 is correct.

Important fact:

It is important to note that top-down methods are more effective than bottom-up methods for regular (Type-3) grammars; however, if a regular grammar only has productions of the form A -> a and A -> Ba (and no others), then the bottom-up method is more effective than the top-down method.

Now think about the grammar that's been provided.

S -> Aa | b

A -> a

Since this regular grammar have productions of the form A -> a and A -> Ba (and no others), thus bottom-up parsing works better for it.

Thus, Statement1 is incorrect and Statement2 is correct.