→ Type checking is the process of verifying and enforcing the constraints of types, and it can occur either at compile time (i.e. statically) or at runtime (i.e. dynamically).
→ Type checking is all about ensuring that the program is type-safe, meaning that the possibility of type errors is kept to a minimum.
→ A language is statically-typed if the type of a variable is known at compile time instead of at runtime. Common examples of statically-typed languages include Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, and Scala.
→ Dynamic type checking is the process of verifying the type safety of a program at runtime. Common dynamically-typed languages include Groovy, JavaScript, Lisp, Lua, Objective-C, PHP, Prolog, Python, Ruby, Smalltalk and Tcl.

Types of compilers

1. Incremental compiler: It rebuilds all program modules, incremental compiler re-compiles only those portions of a program that have been modified.
2. Cross-compiler: If the compiled program can run on a computer whose CPU or operating system is different from the one on which the compiler runs, the compiler is a cross-compiler.
3. A bootstrap compiler: is written in the language that it intends to compile. A program that translates from a low-level language to a higher level one is a decompiler.
4. Source-to-source compiler or transpiler: A program that translates between high-level languages is usually called a source-to-source compiler or transpiler.

→ A Use-Definition Chain (UD Chain) is a data structure that consists of a use, U, of a variable, and all the definitions, D, of that variable that can reach that use without any other intervening definitions. A definition can have many forms but is generally taken to mean the assignment of some value to a variable (which is different from the use of the term that refers to the language construct involving a data type and allocating storage).
→ A counterpart of a UD Chain is a Definition-Use Chain (DU Chain), which consists of a definition, D, of a variable and all the uses, U, reachable from that definition without any other intervening definitions.
→ Both UD and DU chains are created by using a form of static code analysis known as data flow analysis. Knowing the use-def and def-use chains for a program or subprogram is a prerequisite for many compiler optimizations, including constant propagation and common subexpression elimination.

→ Peephole optimization is a kind of optimization performed over a very small set of instructions in a segment of generated code. The set is called a "peephole" or a "window". It works by recognizing sets of instructions that can be replaced by shorter or faster sets of instructions.

Replacement Rules:
1. Null sequences – Delete useless operations.
2. Combine operations – Replace several operations with one equivalent.
3. Algebraic laws – Use algebraic laws to simplify or reorder instructions.
4. Special case instructions – Use instructions designed for special operand cases.
5. Address mode operations – Use address modes to simplify code.

→ Interpreter translates program one statement at a time. Scans the entire program and translates it as a whole into machine code. It takes less amount of time to analyze the source code but the overall execution time is slower.

→ Compiler scans the entire program and translates it as a whole into machine code. It takes large amount of time to analyze the source code but the overall execution time is comparatively faster.

Explanation: The output of a lexical analyzer is a stream of tokens.

Each statement is classified as executable or non-executable.

Executable Statements

1.Arithmetic, logical, statement label (ASSIGN), and character assignment statements

2.Unconditional GO TO, assigned GO TO, and computed GO TO statements

3.Arithmetic IF and logical IF statements

4.Block IF, ELSE IF, ELSE, and END IF statements

5.CONTINUE statement

6.STOP and PAUSE statements

7.DO statement

8.READ, WRITE, and PRINT statements

9.REWIND, BACKSPACE, ENDFILE, OPEN, CLOSE, and INQUIRE statements

10.CALL and RETURN statements

11.END statement

Non-executable Statements

1.PROGRAM, FUNCTION, SUBROUTINE, ENTRY, and BLOCK DATA statements

2.DIMENSION, COMMON, EQUIVALENCE, IMPLICIT, PARAMETER, EXTERNAL, INTRINSIC, and SAVE statements

3.INTEGER, REAL, DOUBLE PRECISION, COMPLEX, LOGICAL, and CHARACTER type-statements

4.DATA statement

5.FORMAT statement

6.Statement function statement

Access time of the symbolic table will be logarithmic if it is implemented by search time.

→ A recursive descent parser is a kind of top-down parser built from a set of mutually recursive procedures (or a non-recursive equivalent) where each such procedure implements one of the nonterminals of the grammar.
→ Thus the structure of the resulting program closely mirrors that of the grammar it recognizes.

→ Top-down parsing can be viewed as an attempt to find leftmost derivations of an input-stream by searching for parse-trees using a top-down expansion of the given formal grammar rules.
→ The inclusive choice is used to accommodate ambiguity by expanding all alternative right-hand-sides of grammar rules.

→ Peephole optimization technique works locally on the source code to transform it into an optimized code.
→ By locally, we mean a small portion of the code block at hand.
→ These methods can be applied on intermediate codes as well as on target codes.

Expressions with constant operands can be evaluated at compile time, thus improving run-time performance and reducing code size by avoiding evaluation at compile-time.
Example:
In the code fragment below, the expression (3 + 5) can be evaluated at compile time and replaced with the constant 8.

int f (void)
{
return 3 + 5;
}

Below is the code fragment after constant folding.

int f (void)
{
return 8;
}

Both statements are wrong. I. Logical errors can’t solve in compile time. Like dividing by error.
II. In c++ also we have to write exceptions.

2-pass Assembler can perform all of above operations.

An optimization method in which an operator is changed to a less-expensive operator;
Example: Exponentiation is replaced by multiplication and multiplication is in return replaced by addition.(x * 2 becomes x + x)

Peephole optimization is a type of Code Optimization performed on a small part of the code. It is performed on the very small set of instructions in a segment of code.
It basically works on the theory of replacement in which a part of code is replaced by shorter and faster code without change in output.

C is the useless variable as there is no production rule which replaces C with a terminal. Hence it does not derive any non terminal.

→ A shift-reduce parser is a class of efficient, table-driven bottom-up parsing methods for computer languages and other notations formally defined by a grammar.
→ The parsing methods most commonly used for parsing programming languages, LR parsing and its variations, are shift-reduce methods.

A bottom-up parser uses Right-most derivation in reverse order to decide “What to Reduce”.

Step-1: Initialization we are taking one node
Step-2: From 2nd statement to 6th statement we are performing some tasks.
Step-3: It indicate if condition, so it’s another statement. And the back loop indicates goto statement.
Here, total 3 nodes and 3 edges using control flow graph.

In options they have to give like this
3 and 3
4 and 4
4 and 3
3 and 4
But they combines the node value and edge value. It seems different value.

Symbol Table is an important data structure created and maintained by the compiler in order to keep track of semantics of variable i.e. it stores information about scope and binding information about names, information about instances of various entities such as variable and function names, classes, objects, etc.
Symbol Table entries: Each entry in symbol table is associated with attributes that support
→ compiler in different phases.
→ Items stored in Symbol table:
→ Variable names and constants
→ Procedure and function names
→ Literal constants and strings
→ Compiler generated temporaries
→ Labels in source languages

The tokens are
Printf
(
“A%B=”
,
&
I
)
;

Strength Reduction :
It is a compiler optimization where expensive operations are replaced with equivalent but less expensive operations. The classic example of strength reduction converts "strong" multiplications inside a loop into "weaker" additions – something that frequently occurs in array addressing.
Examples:
Replacing a multiplication within a loop with an addition
Replacing an exponentiation within a loop with a multiplication
According to options, Option B is most suitable answer.

→ Loop fusion (or loop jamming) is a compiler optimization and loop transformation which replaces multiple loops with a single one.
→ Loop fission (or loop distribution) is a compiler optimization in which a loop is broken into multiple loops over the same index range with each taking only a part of the original loop's body.

→ Loop fusion (or loop jamming) is a compiler optimization and loop transformation which replaces multiple loops with a single one.
→ Loop fission (or loop distribution) is a compiler optimization in which a loop is broken into multiple loops over the same index range with each taking only a part of the original loop's body.

● The transfer vector approach is straightforward, but requires additional memory at execution time for the transfer vector and additional time due to the indirect references. Indexing or indirection on externals may not occur correctly with the transfer vector approach.
● Data segment stores program data. This data could be in form of initialized or uninitialized variables, and it could be local or global.
● External subroutines are routines/procedures that are created and maintained separately from the program that will be calling them

● YACC (Yet Another Compiler-Compiler) is a computer program.
● It is a Look Ahead Left-to-Right (LALR) parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to Backus–Naur Form (BNF)

● Micro program is a set of microinstructions that defines the individual operations that a computer carries out in response to a machine-language instruction.
● A ​ microinstruction​ is a bit pattern in which each bit (or combination of bits) drives the control signals of the hardware.

Since it is given that the grammar cannot have:
1) epsilon production
2) production of the form A → a
Consider the grammar:
S → Sa | a
If we were to derive the string “aaa” whose length is 3 then the number of reduce moves that would have been required are shown below:
S→ Sa
→Saa
→aaa
This shows us that it has three reduce moves. The string length is 3 and the number of reduce moves is also 3. So presence of such kinds of production might give us the answer “n” for maximum number of reduce moves. But these productions are not allowed as per the question.
Also note that if a grammar does not have unit production then the maximum number of reduce moves can not exceed “n” where “n” denotes the length of the string.
3) No unit productions
Consider the grammar:
S→ A
A→ B
B→C
C→a
If we were to derive the string “a” whose length is 1 then the number of reduce moves that would have been required are shown below:
S→ A
A→ B
B→C
C→a
This shows us that it has four reduce moves. The string length is 1 and the number of reduce moves is 4. So presence of such kind of productions might give us the answer “n+1” or even more, for maximum number of reduce moves. But these productions are not allowed as per the question.
Now keeping in view the above points suppose we want to parse the string “abcd”. (n = 4) using bottom-up parsing where strings are parsed finding the rightmost derivation of a given string backwards. So here we are concentrating on deriving rightmost derivations only.
We can write the grammar which accepts this string which in accordance to the question, (i.e., with no epsilon- and unit-production (i.e., of type A → є and A → B) and no production of the form A→a) as follows:
S→aB
B→bC
C→cd
The Right Most Derivation for the above is:
S → aB (Reduction 3)
→ abC (Reduction 2)
→ abcd (Reduction 1)
We can see here the number of reductions present is 3.
We can get less number of reductions with some other grammar which also doesn’t produce unit or epsilon productions or production of the form A→a:
S→abA
A→ cd
The Right Most Derivation for the above is:
S → abA (Reduction 2)
→ abcd (Reduction 1)
Hence 2 reductions.
But we are interested in knowing the maximum number of reductions which comes from the 1st grammar. Hence total 3 reductions as maximum, which is (n – 1) as n = 4 here.

Lexical analysis is the first phase of a compiler. It takes the modified source code from language preprocessors that are written in the form of sentences.
The lexical analyzer breaks these syntaxes into a series of tokens, by removing any whitespace or comments in the source code.
In programming language, keywords, constants, identifiers, strings, numbers, operators and punctuations symbols can be considered as tokens.

An assembler is a type of computer program that interprets software programs written in assembly language into machine language, code and instructions that can be executed by a computer.
A loader which combines the functions of a relocating loader with the ability to combine a number of program segments that have been independently compiled into an executable program.
A cross compiler is a compiler capable of creating executable code for a platform other than the one on which the compiler is running.

→ Statement I is true, as the bottom up and top down parser take O(n) time to parse the string , i.e. only one scan of input is required.
→ Statement II is false, as a programming language which allows recursion requires dynamic storage allocation.
→ Statement III is True, as L-attributed definition (assume for instance the L-attributed definition has synthesized attribute only) can be evaluated in bottom up framework.
→ Statement IV is true,Code improving transformations can be performed at both source language and intermediate code level. For example implicit type casting is also a kind of code improvement which is done during semantic analysis phase and intermediate code optimization is a topic itself which uses various techniques to improve the code such as loop unrolling, loop invariant.

Data segment − It is represented by .data section and the .bss. The .data section is used to declare the memory region, where data elements are stored for the program. This section cannot be expanded after the data elements are declared, and it remains static throughout the program.
The .bss section is also a static memory section that contains buffers for data to be declared later in the program. This buffer memory is zero-filled.
Code segment − It is represented by .text section. This defines an area in memory that stores the instruction codes. This is also a fixed area.

The grammar is ambiguous, as to derive string ( )( )( ) more than one parse tree exists.

Pseudo Instructions are special commands to the assembler about the positioning of the program, the address the program should presumed to be assembled at, the name of the module, data declarations, the title and printing options for the program, defining and calling macros, macro looping and test, and end of source code. Unless a machine instruction is issued, these do not generate executable code.

For generating string “c” we have two different parse trees.

Since the grammar is Ambiguous so the strings generated by the grammar G can’t be parsed by LR(1) or LL(1) parser.

● Constant folding is the process of recognizing and evaluating constant expressions at compile time rather than computing them at runtime.It can more accurately propagate constants and simultaneously remove dead code
● Global optimization refers to finding the optimal value of a given function among all possible solution whereas local optimization finds the optimal value within the neighboring set of candidate solution.
● Loop optimization is the process of increasing execution speed and reducing the overheads associated with loops. It plays an important role in improving cache performance and making effective use of parallel processing capabilities. Most execution time of a scientific program is spent on loops; as such, many compiler optimization techniques have been developed to make them faster.
● Data-flow analysis is a technique for gathering information about the possible set of values calculated at various points in a computer program.

Semantics defines how a particular pattern to be interpreted, and what action is to be taken based on that interpretation.

→ Flow graph shows the basic blocks
→ A flow graph is a form of digraph associated with a set of linear algebraic or differential equations.
Definition: "A signal flow graph is a network of nodes (or points) interconnected by directed branches, representing a set of linear algebraic equations. The nodes in a flow graph are used to represent the variables, or parameters, and the connecting branches represent the coefficients relating these variables to one another. The flow graph is associated with a number of simple rules which enable every possible solution [related to the equations] to be obtained."

● When the parser starts constructing the parse tree from the start symbol and then tries to transform the start symbol to the input, it is called top-down parsing.
● Top-down parsing can be viewed as an attempt to find leftmost derivations of an input-stream by searching for parse-trees using a top-down expansion of the given formal grammar rules.

Syntax-directed translation refers to a method of compiler implementation where the source language translation is completely driven by the parser.
A common method of syntax-directed translation is translating a string into a sequence of actions by attaching one such action to each rule of a grammar.

● Lexical analysis is the first phase of a compiler. It takes the modified source code from language preprocessors that are written in the form of sentences.
● The lexical analyzer breaks these syntaxes into a series of tokens, by removing any whitespace or comments in the source code.

The operator which is in low level that can have high preference.
Order of precedence is *, +, -.
Here * and + have equal preference, '-' can have higher precedence than + and *.

Operator values doesn't contains nullable values and two adjacent non-terminals on RHS production.
i) On RHS it contains two adjacent non-terminals.
ii) Have nullable values.

→ Yacc (Yet Another Compiler-Compiler) is a computer program for the Unix operating system developed by Stephen C. Johnson.
→ It is a Look Ahead Left-to-Right (LALR) parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to Backus-Naur Form (BNF)

Option-A: LR > LALR > SLR

Canonical LR parser is more powerful than LALR parser. So, it FALSE

Option-B: Here, LP is linear precedence. Every grammar generated by LP are CFG but all CFG's are not LP. So, it is false

Option-C: TRUE

Option-D: LR(K) is general non backtracking shift reduce parsing method. So, It is false

A recursive descent parser is a kind of top-down parser built from a set of mutually recursive procedures (or a non-recursive equivalent) where each such procedure implements one of the nonterminals of the grammar. Thus the structure of the resulting program closely mirrors that of the grammar it recognizes.
→ Top down parsers reads the input from left to right and bottom up parsers are reads the input from left to right and reverse.

Bottom Up SR Parsers are:
1. SLR
2. LALR
3. CLR
4. LR(0)
Top Down parser:
1. Recursive descent
2. Non Recursive descent(LL(1))

The space of grammars:

→ An optimizing compiler is a compiler that tries to minimize or maximize some attributes of an executable computer program.
→ The most common requirement is to minimize the time taken to execute a program; a less common one is to minimize the amount of memory occupied.
→ The growth of portable computers has created a market for minimizing the power consumed by a program

Parsing, syntax analysis, or syntactic analysis is the process of analysing a string of symbols, either in natural language, computer languages or data structures, conforming to the rules of a formal grammar. The term parsing comes from Latin pars (orationis), meaning part (of speech).

→ A linker is a computer utility program that takes one or more object files generated by a compiler and combines them into a single executable file, library file, or another 'object' file.
→ A loader is a major component of an operating system that ensures all necessary programs and libraries are loaded, which is essential during the startup phase of running a program.
→ It places the libraries and programs into the main memory in order to prepare them for execution.

→ Compiler : Compilers are used to convert high level languages (like C, C++ ) into machine code Example : gcc , Microsoft Visual Studio
→ Assembers : Assembler are used to convert assembly language code into machine code.
→ Interpreter : An interpreter is a computer program which executes a statement directly (at runtime).
→ Examples: python , LISP

● A ​ Synthesized attribute ​ is an attribute of the nonterminal on the left-hand side of a production.
● Synthesized attributes represent information that is being passed up the parse tree.
● LR-attributed grammars allow the attributes to be evaluated on LR parsing. As a result, attribute evaluation in LR-attributed grammars can be incorporated conveniently in bottom-up parsing.

The condition for a grammar to be LL(1)
Theorem: A context free grammar G=(V​ _T​ , V_{​ N}​ , S,P) is LL(1) if and if only if for every nonterminal A and every strings of symbols ⍺,β such that ⍺≠β and A → ⍺,β we have
1. First(⍺) ∩ First (β) ∩ Follow(A)=Θ.
2. If ⍺ *⇒ ε then First(β) ∩ Follow(A)= Θ.
If grammar is epsilon free then condition 2 is not required.
Now as per condition 1, for every non-terminal A, if we have A → u and A→v
And First(u) First(v) = φ and CFG is epsilon free then it must be LL(1) and if epsilon free CFG is LL(1) then it must satisfy the condition 1.

The following tasks should be performed in semantic analysis:
1. Scope resolution
2. Type checking
3. Array-bound checking

Lexical analyzer reads the characters from source code and convert it into tokens.
Different tokens or lexemes are:
→Keywords
→Identifiers
→Operators
→Constants

Parser→ A part of a compiler that is responsible for recognizing synta
Scanner→ An IR-to-IR transformer that tries to improve the IR program in some way (Intermediate representation)
Semantic Analysis→ A part of a compiler that understand the meaning of variable names and other symbols and checks that they are used in ways consistent with their definitions
Optimizer→ An IR-to-IR transformer that tries to improve the IR program in some way (Intermediate representation)

→ The capacity of a system to adapt the increased service load is called scalability.
→ Scalability is the capability of a system, network, or process to handle a growing amount of work, or its potential to be enlarged to accommodate that growth.
Note: A scalable system is any system that is flexible with its number of components.

FALSE: Lexical Analysis is specified by regular grammars and implemented by finite automata.
FALSE: Syntax Analysis is specified by context-free grammars and implemented by pushdown automata.

Option (A)​ is not correct because multiplication operation can be performed faster using Left-Shift(<<) operator instead of "+" operator and "3+4=7" is the example of Folding machine independent optimization method instead of operator strength reduction .
Option(B)​ is correct because here to speedup the multiplication operation, * operator is replaced by Left-Shift operator.
Option(C)​ is not correct because the method used for compiler optimization is not correct. For given statements to perform compiler optimization, we simply eliminate such statements from the code and this method of elimination is called as Algebraic Simplification.
Option(D)​ is also not correct because bitwise operator is more faster than multiplication.

Linker:
A linker or link editor is a computer utility program that takes one or more object files generated by a compiler and combines them into a single executable file, library file, or another 'object' file.
Principles:
1. Resolve external references among separately compiled program units
2. Relocate code and data relative to the beginning of the program.
→ Assembler, Translate assembly language to machine code.

Loop Unrolling:​ Loop unrolling refers to method of decreasing the number of time a loop is executed.
Strength reduction:​ It is a machine independent code optimization technique in which a costly operation(operation which takes more time to execute) is replaced with the cheaper. operation(operation which takes less execution time)
Loop Jamming:​ It is a loop optimization technique in which bodies of two loops are combined together to decrease the number of loops.

TRUE: Reduction in overall program execution time.
FALSE: Reduction in overall space consumption in memory.
FALSE: Reduction in overall space consumption on disk.
FALSE: Reduction in the cost of software updates.
Note: Except statement-I remaining all statements are not related to dynamic linking.

A grammar is said to be ambiguous if and only if it can generate parse trees of both ​ Left ​ Most Derivation or Right Most Derivation.
In this grammar we are having two different parse trees For string "aabb" using leftmost derivation only.

Statement B is wrong because in LALR we use lookahead symbols to put the reduce entries into the parsing table. Because of which number of blank entries in LALR parser are more than that of SLR parser which in turn increases the error detection capability of LALR parser. So LALR parser is more powerful than SLR.
Statement C is true because LL(1) parser is a top-down parser
Statement D is also true because YACC(Yet Another Compiler Compiler) is a tool which generates LALR parser for a given grammar.

→ Loop unrolling is a code optimization technique that avoids tests at every iteration of the loop.
→ The goal of loop unwinding is to increase a program's speed by reducing (or) eliminating instructions that control the loop, such as pointer arithmetic and "end of loop" tests on each iteration.

→ The C preprocessor is a macro preprocessor (allows you to define macros) that transforms your program before it is compiled. These transformations can be inclusion of header file, macro expansions,etc,...
→ All preprocessing directives begins with a # symbol. For example,
#define PI 3.14

TRUE: LALR parser is Bottom up parsers.
TRUE: LR parser is Bottom up parser. It has SLR, LALR and SLR.
TRUE: In LL(1), the 1 indicates that there is a one - symbol look - ahead.
FALSE: A parsing algorithms scans right to left and reverse order.

Syntax analysis: understanding the structure of the source code
1. Tokenizing: creating a stream of “atoms”
2. Parsing: matching the atom stream with the language grammar
XML output = one way to demonstrate that the syntax analyzer works

Two Pass Assemblers:
Pass-1:
1. Assign addresses to all statements in the program
2. Save the values assigned to all labels for use in Pass2
3. Perform some processing of assembler directives
Pass-2:
1. Assemble instructions Generate data values defined by BYTE,WORD
2. Perform processing of assembler directives not done in Pass 1
3. Write the object program and the assembly listing

Code optimization is responsibility of system programmer.

Two Pass Assemblers:
Pass-1:
1. Assign addresses to all statements in the program
2. Save the values assigned to all labels for use in Pass2
3. Perform some processing of assembler directives
Pass-2:
1. Assemble instructions Generate data values defined by BYTE,WORD
2. Perform processing of assembler directives not done in Pass-1
3. Write the object program and the assembly listing.
Activities:
1. Build the symbol table
2. Construct the intermediate code
3. Separate mnemonic opcode and operand fields

In two pass assembler the symbol table is used to store memory location.

→ Top-down parsing can be viewed as an attempt to find leftmost derivations of an input-stream by searching for parse-trees using a top-down expansion of the given formal grammar rules.
→ Inclusive choice is used to accommodate ambiguity by expanding all alternative right-hand-sides of grammar rules.

→ A macro processor is a program that copies a stream of text from one place to another, making a systematic set of replacements as it does so.
→ Macro processors are often embedded in other programs, such as assemblers and compilers. Sometimes they are standalone programs that can be used to process any kind of text.

Two Pass Assemblers:
Pass-1:
1. Assign addresses to all statements in the program
2. Save the values assigned to all labels for use in Pass2
3. Perform some processing of assembler directives
Pass-2:
1. Assemble instructions Generate data values defined by BYTE,WORD
2. Perform processing of assembler directives not done in Pass 1
3. Write the object program and the assembly listing

TRUE: Lexical analysis is breaking the input into tokens
TRUE: Syntax analysis is for parsing the phrase
FALSE: Syntax analysis is for analyzing the semantic. For analysing semantics we are using semantic analysis but not syntax analysis

The dynamic binding occurs during the run time. The method being called upon an object or the function being called with arguments is looked up by name at runtime.

A symbol table can be used for
1. To store the names of all entities in a structured form at one place.
2. To verify if a variable has been declared.
3. To implement type checking, by verifying assignments and expressions in the source code are semantically correct.
4. To determine the scope of a name (scope resolution).

→ Incremental compiler: The compiler which compiles only the changed lines from the source code and update the object code
→ Threaded code compiler: The compiler which simply replace a string by an appropriate binary code.
→ Cross compiler: The compiler used to compile a source code for different kinds platform.
**One pass assembler and two pass assemblers are available.

→ The name LR is often followed by a numeric qualifier, as in LR(1) or sometimes LR(k). To avoid backtracking or guessing, the LR parser is allowed to peek ahead at k lookahead input symbols before deciding how to parse earlier symbols.
→ Typically k is 1 and is not mentioned. The name LR is often preceded by other qualifiers, as in SLR and LALR. The LR(k) condition for a grammar was suggested by Knuth to stand for "translatable from left to right with bound k."

→ Peephole optimization is a kind of optimization performed over a very small set of instructions in a segment of generated code. The set is called a "peephole" or a "window". It works by recognizing sets of instructions that can be replaced by shorter or faster sets of instructions.
Common techniques:
Null sequences
Combine operations
Algebraic laws
Special case instructions
Address mode operations
Constant folding

A permanent database of a general model of compiler is terminal table. A permanent database that has entry for each terminal symbols such as arithmetic operators, keywords, punctuation characters such as ‘;’, ‘,’etc Fields: Name of the symbol.

Tasks done in parsing are check the validity of a source string and determine the syntactic structure of a source string.

Yacc (Yet Another Compiler-Compiler):
It is a Look Ahead Left-to-Right (LALR) parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specifically a LALR parser, based on an analytic grammar written in a notation similar to Backus–Naur Form (BNF).
**YACC builds up LALR parsing table.

Lexical analysis is the first phase of a compiler. It takes the modified source code from language preprocessors that are written in the form of sentences. The lexical analyzer breaks these syntaxes into a series of tokens, by removing any whitespace or comments in the source code.

The dynamic binding occurs during the run time. The method being called upon an object or the function being called with arguments is looked up by name at runtime.

Shift-Reduce parsers perform shift step that advances in the input stream by one symbol and Reduce step that applies a completed grammar rule to some recent parse trees, joining them together as one tree with a new root symbol.

TRUE: Canonical LR parser is LR (1) parser with single look ahead terminal
TRUE: All LR(K) parsers with K > 1 can be transformed into LR(1) parsers.

→ In a two-pass assembler, symbol table is generated in first pass.
→ The first pass of the assembler reads and processes the assembly program one line at a time. In processing a single line of the assembly program the assembler can make addition(s) to the symbol table, add a (possibly partial) SML instruction to the Simpletron's memory.
→ The purpose of the second pass is to complete the partial instructions written in the first pass.

Debugger is a program that allows to set breakpoints, execute a segment of program and display contents of register.

A grammar G is LL(1) if and only if the following conditions hold for two distinct productions:
A → α | β
1. First (α) and First (β) must be disjoint if none of α and β contains NULL move.
2. At most one of the strings α or β can drive NULL move i.e. α → NULL(since First (α) and First (β) are disjoint). In this case, First (β) and Follow(A) must be disjoint.
Hence the answer is option(D).

→ Left recursion removing (or) factoring the given grammar are not sufficient to convert an arbitrary CFG to an LL(1) grammar.
→ To convert an arbitrary CFG to an LL(1) grammar we need to remove the left recursion and as well as left factoring without that we cannot convert.

→ A shift-reduce parser scans and parses the input text in one forward pass over the text, without backing up. (That forward direction is generally left-to-right within a line, and top-to-bottom for multi-line inputs.) The parser builds up the parse tree incrementally, bottom up, and left to right, without guessing or backtracking.
A shift-reduce parser works by doing some combination of Shift steps and Reduce steps, hence the name.
→ A Shift step advances in the input stream by one symbol. That shifted symbol becomes a new single-node parse tree.
→ A Reduce step applies a completed grammar rule to some of the recent parse trees, joining them together as one tree with a new root symbol.
*** A shift reduce parser suffers from both shift reduce conflict and reduce reduce conflict.

The grammar is ambiguous, as to derive string ()()() more than one parse tree exists.

For generating string “c” we have two different parse trees.

Since the grammar is Ambiguous so the strings generated by the grammar G can’t be parsed by LR(1) or LL(1) parser.

A grammar is said to be ambiguous if we get two different parse trees using either Leftmost derivation only or Rightmost derivation only.
To generate string “ababa” using G1 grammar the two different parse tree possible are:

A bottom-up parser uses Right-most derivation in reverse order to decide “What to Reduce”.

In compiler design ‘reducing the strength’ refers to code optimization using cheaper machine instructions.
Example:
Dividing by 2→ Use right shift by 2.
Multiplication by 2→ Use left shift by 2.

The operator which is in low level that can have high preference.
Order of precedence is *, +, -.
Here * and + have equal preference, '-' can have higher precedence than + and *.

→ A grammar could be LL(1) if and only if it is unambiguous and is not left recursive and left factoring grammar.
→ Since for converting a grammar to LL(1) 3 conditions mentioned above are required.
→ Unambiguous grammar is not mentioned in options. So option (D) is the correct.

Canonical LR is most powerful.
LR > LALR > SLR.
But real time compilers using LALR only

→ Top down parsers using leftmost derivation and the input is scanned from left to right.
→ Bottom up parsers using rightmost derivation in reverse.

→ Compiler translates the entire source program into once. So, it is faster than interpreter.
→ Interpreter translates the source program into line by line. So, it is slower than compiler.

Portable program means independent of platform. We can run same program in any operating system like windows,linux,unix,etc..,

Different ways a macro processor for assembly language can be implemented.
1. Independent two-pass processor
2. Independent one-pass processor
3. Expand macro calls and substitute arguments

A “handle” of a string is a substring that matches the RHS of a production and whose reduction to the non-terminal (on the LHS of the production) represents one step along the reverse of a rightmost derivation toward reducing to the start symbol.
And in above question aSb is a handle because it's reduction to the LHS of production A → aSb represents one step along the reverse of a rightmost derivation toward reducing to the start symbol.

Given grammar can generate { β₁, β₂ , β₂α₂, , β₂ α₁, , β₁α₂, , β₁α1 , β₁ α₁α₂..................}
Option A can generate only {β₁, β₂} so it is not a correct option.
Option B is not correct because it have no terminating point strings containing {α₁ , α₂}
Option C is not correct because it can generate only {β₁, β₂}
Option D is correct answer because it can generate all the strings generated by given grammar.

Statement-1: → See the symbol (⇒ *) means after some step , here * represent an arbitrary number of steps. * is not part of terminal.
→ So if alpha after some step has t as first symbol (terminal) in some sentential form , then first(alpha) must be {t}
Statement-2:
α→∗tβ Here First(α) = {*} .
S→∗αXaβ
Follow(X) = {a}
So Statement S2 is correct.

→ A macro is a sequence of instructions, assigned by a name and could be used anywhere in the program.
→ A macro is an extension to the basic ASSEMBLER language. They provide a means for generating a commonly used sequence of assembler instructions/statements.
→ The sequence of instructions/statements will be coded ONE time within the macro definition. Whenever the sequence is needed within a program, the macro will be "called".

→ Grammar of the programming is checked at syntax phase of compiler.
→ logical errors will checked in semantic analysis.
→ Code optimization and code generation is not related to checking errors. It is reducing statement or performing optimization.

→ A macro processor is a program that copies a stream of text from one place to another, making a systematic set of replacements as it does so.
→ Macro processors are often embedded in other programs, such as assemblers and compilers.

Parse tree is always following inorder traversal. It visit left,root and right.

Actually they are given in wrong order.
But according to given question, we are giving precedence is
(((3 – 2) *) 4 $ | * (2**3))
Step-1: 3-2=1
Step-2: 1*4=4
Step-3: 2*3=6
Step-4: 4⁶=4096
Note: When we are assuming ** is single(*) and there is no |* are useless symbols.

Lexical analysis(or Scanner) used for grouping of characters into tokens.

Cross compiler: The compiler used to compile a source code for different kinds platform.
Note: We have an one and two pass assemblers but not compilers.

→ Loader loads the executable code into memory, program and data stack are created, register gets initialized.
→ Re-allocation is an absolute loading scheme which loader function is accomplished by assembler

LR(1)is default name of CLR(1). Hence LR(1) and CLR(1) is same.
Option(A):
Since here we are having no Reduce-reduce OR shift-reduce conflict so it is CLR(1).

⇒ 23131
SR is bottom up parser.
Note : Instead of Sz they given S2 and what operation will perform they are not mentioned

→ Synthesized Attributes are such attributes that depend only on the attribute values of children nodes. It can be easily simulated by LR grammar
→ Inherited Attributes are such attributes that depend on parent and/or siblings attributes.

Basic Assembly directives:
1. EQU→ Equate
2. ORIGIN→ Origin
3. START→ Start
4. END→ End

→ Assembler program is dependent on the hardware.
→ An assembler program creates object code by translating combinations of mnemonics and syntax for operations and addressing modes into their numerical equivalents.

At end of parsing whether it is syntactically correct or not is identified So at end of parsing
1. tokens are identified
2. whether the given code is syntactically correct or not is identified.

→ Dead code elimination in machine code optimization refers to removal of values that never get used.
→ Dead code includes code that can never be executed (unreachable code), and code that only affects dead variables (written to, but never read again), that is, irrelevant to the program.

A parse tree is an annotated parse tree if it shows attribute values at each node.
Features:
1. High level specification
2. Hides implementation details
3. Explicit order of evaluation is not specified

→ In a two pass compiler, during the first pass, user defined address symbols are correlated with their binary equivalent.
→ During first pass in two pass compilers contain lexical,syntactic,semantic and intermediate code generator are in front end.
→ During second pass in two pass compilers contain code optimization and code generator are in back end.

A single instruction in an assembly language program contains one macro operation.

Absolute loader demands that the programmer needs to know the start address of the available main memory.

→ Top-down parsers are predictive parsers, because next tokens are predicted.
→ Predictive parser is a recursive descent parser, which has the capability to predict which production is to be used to replace the input string.
→ The predictive parser does not suffer from backtracking.
→ Predictive parsing uses a stack and a parsing table to parse the input and generate a parse tree.

In the context of compiler design, “reduction in strength” refers to code optimization obtained by the use of cheaper machine instructions.

→ Top-down parsers are predictive parsers, because next tokens are predicted.
→ Predictive parser is a recursive descent parser, which has the capability to predict which production is to be used to replace the input string.
→ The predictive parser does not suffer from backtracking.
→ Predictive parsing uses a stack and a parsing table to parse the input and generate a parse tree.

→ A Top down Parser generates leftmost derivation.
→ A bottom up parser generates rightmost derivation, in reverse.

Symbol table can be used for
1. Checking type compatibility
2. Suppressing duplication of error message
3. Storage allocation

→ Heap allocation is required for languages that support dynamic data structures. The heap is managed via calls to new, delete, callac, realloc, malloc, free, etc.
→ Stack allocation is required for local variables. Space on the stack is reserved for local variables when they are declared.