Solution

Relocation changes the assigned address of data and code in the program.

Solution

Removal of comment is not performed during compilation, infact comments are never removed in any phase. Comments are ignored in lexical analysis (i.e, during compilation). Similarly during compilation Type checking, symbol table management and inline expansion are performed.

Solution

Intermediate code is generated after semantic analysis. The intermediate code is independent of machine. By converting source code to intermediate code a machine independent code optimizer may be written. Thus increase the chances of reusing the machine-independent code optimizer in other compilers.

Solution

Dynamic memory is allocated in the heap memory by the system. So the languages which allow dynamic data structure require heap allocation at runtime.

Solution

Keywords are identified at lexical analysis phase by lexical analyser.

Solution

The code-optimization on intermediate code generation will always enhance the portability of the compiler to target processors. The main reason behind this is, as the intermediate code is independent of the target processor on which the code will be executed, so the compiler is able to optimize the intermediate code more conveniently without bothering the underlying architecture of target processor.

Solution

The statement, static allocation of all data areas by a compiler makes it impossible to implement recursion is true, as recursion requires memory allocation at run time, so it requires dynamic allocation of memory. Hence, Dynamic allocation of activation records is essential to implement recursion is also a true statement.

Solution

Solution

S-> (S) { S.count = S₁.count+1 }

S-> SS { S.count = S₁.count + S₂.count }

S-> ϵ {S.count = 0}

Consider a string (( )₁ ( ( )₂ )₃ )₄

The counting is carried by:

Solution

Both statements are correct. An annotated parse tree is a parse tree showing the values of the attributes at each node. The process of computing the attribute values at the nodes is called annotating or decorating the parse tree.

Solution

Explanation for S1:

Quadruples and triples are the two forms of three-address code. Three address code is used for representing intermediate code generation. A three address code has at most three address locations to calculate the expressions.

Consider the expression:

a = b + c * d

The three address code for the above expression is:

r1 = c * d;

r2 = b + r1;

r3 = r2 + r1;

a = r3;

Quadruple representation:

--------------------------

Representing the above three address code in quadruple representation.

Each instruction in quadruple representation is divided into four fields: operator, arg1, arg2 and arg3 result.

Triples representation:

----------------------------

Representing the above three address code in triples representation.

Each instruction in triples representation is divided into three fields: op, arg1,

arg2.

So we can see clearly that quadruple representation requires more space compared to triple notation. So, statement S1 is true.

Explanation for S2:

The representation is an enhancement over triples representation. It uses pointers instead of position to store results.

Because of implementing pointers there are two memory accesses.

1st access: We have to refer the pointer to get the address of the instruction.

2nd access: Going from pointers to instruction file itself.

This increases the access time which proves to be a disadvantage.

So statement S2 is true.

Solution

With intermediate code: 3+4=7

Without intermediate code: 3×4=12

If we generate machine code directly from source code (without intermediate code ) then for 4 languages and 3 machines we need to 4*3 target code generators.

By converting source code to intermediate code a machine independent code optimizer may be written. So we require only 4 front ends + 1 code optimiser + 3 target code generator.

Plz notice earlier 4*3 target code generators are required but with intermediate step (as machine independent code optimiser are there) we require only 4 front end + 3 target code generator.

Solution

Solution

In rule 2 for production A-> XY the attribute “i” is calculated from the right sibling Y in X.i= A.i + Y.s which is violating the L attribute definition, as in L attribute calculating attribute vale from RHS sibling is not allowed.

Solution

The given grammar is:

S → aSb {S.val = S.val+2}

| bSa {S.val = S.val+2}

| ϵ

Let us evaluate the string “a a b a b b”

The parse tree for the given string:

So it gives 6 as the result of evaluation which is the number of a’s and b’s in the string.