Translate $a = (a + b)\,(c + d) + (a + b + c)$ into Quadruple, Triple, and Indirect Triple

We translate the expression into three common intermediate-code formats used in compiler design: keyword-style Quadruple , keyword-style Triple , and keyword-style Indirect Triple.

Let the target expression be:

$$a = (a+b)\,(c+d) + (a+b+c)$$

We compute subexpressions in a consistent evaluation order (typically following operator precedence: parentheses first, then $*$, then $+$).

Key keyword{temporaries} like $t1,t2,\dots$ will appear as results in the Quadruple form and implicitly as indices in the Triple form.

Expression decomposition

We identify the parenthesized parts:

• $(a+b)$
• $(c+d)$
• $(a+b+c)$ which can be expanded as $(a+b)+c$ (since $+$ is associative)

Then the full expression becomes:

$$a = \underbrace{(a+b)\,(c+d)}_{\text{term1}} + \underbrace{(a+b+c)}_{\text{term2}}$$

We will generate intermediate operations in this order:

1. $t1 = a+b$
2. $t2 = c+d$
3. $t3 = t1*t2$
4. $t4 = a+b$
5. $t5 = t4+c$
6. $t6 = t3+t5$
7. $a = t6$

Note: Recomputing $(a+b)$ twice (steps 1 and 4) is normal unless you perform common subexpression elimination.

(i) Quadruple representation

Quadruple format is:

$$(op,\ arg1,\ arg2,\ result)$$

We number temporaries explicitly as $t1,t2,\dots$:

Notes

• For assignment, we often write $=$ with one meaningful operand; arg2 can be shown as “-”.
• This form makes the destination explicit each row.

(ii) Triple representation

Triple format stores:

$$(op,\ arg1,\ arg2)$$

and the “result” is the index of that triple. So if triple 3 is $(\ *,\ t1,\ t2)$, then its computed value is referenced as $(3)$.

We list triples $T1$ … $T7$ (index-based):

Here:

• triple $1$ computes $t1$
• triple $2$ computes $t2$
• triple $3$ computes $t3$
• triple $4$ computes $t4$
• triple $5$ computes $t5$
• triple $6$ computes $t6$
• triple $7$ assigns $a=(6)$

keyword{Index referencing} is why there is no explicit “result” field per row.

(iii) Indirect triple representation

Indirect Triple is typically implemented using:

1. a triple table (same $(op,arg1,arg2)$ entries as triples), and
2. an keyword{indirection table} that maps temporaries/identifiers to indices.

A common presentation:

• You still create triples $T1\dots$
• But when an operand refers to a temporary, you store a pointer to the triple entry rather than the temporary name itself.

A clear way to show it is:

• triple entries are the same as part (ii)
• an indirection array $I[\ ]$ gives which triple index a temporary points to

Triple table (base)

We reuse the triple table from (ii):

Indirection table (example)

Let temporaries correspond to the produced triple indices:

• $t1 \rightarrow 1$
• $t2 \rightarrow 2$
• $t3 \rightarrow 3$
• $t4 \rightarrow 4$
• $t5 \rightarrow 5$
• $t6 \rightarrow 6$

Then an “indirect triple” operand is effectively “use the value produced by the triple index stored in $I[t]$”.

So the operand references in the indirection style are:

• Use $I[t1]=1$ instead of writing $t1$
• Use $I[t2]=2$ instead of writing $t2$
• etc.

A compact indirection representation for the final computation is:

• triple 6 computes $t6$: $(6):\ +\ \big(I[t3]\big)\ \big(I[t5]\big)$
• assignment triple 7 stores into $a$: $(7):\ =\ \big(I[t6]\big)$

Mermaid view (what indirection changes)