Precedence Table Construction Algorithm for CFGs Regardless of Being OPGs

Abstract

Operator precedence grammars (OPG) are context-free grammars (CFG) that are characterized by the absence of two adjacent non-terminal symbols in the body of each production (right-hand side). Operator precedence languages (OPL) are deterministic and context-free. Three possible precedence relations between pairs of terminal symbols are established for these languages. Many CFGs are not OPGs because the operator precedence cannot be applied to them as they do not comply with the basic rule. To solve this problem, we have conducted a thorough redefinition of the Left and Right sets of terminals that are the basis for calculating the precedence relations, and we have defined a new Leftmost set. The algorithms for calculating them are also described in detail. Our work’s most significant contribution is that we establish precedence relationships between terminals by overcoming the basic rule of not having two consecutive non-terminals using an algorithm that allows building the operator precedence table for a CFG regardless of whether it is an OPG. The paper shows the complexities of the proposed algorithms and possible exceptions to the proposed rules. We present examples by using an OPG and two non-OPGs to illustrate the operation of the proposed algorithms. With these, the operator precedence table is built, and bottom-up parsing is carried out correctly.

1. Introduction

This paper delves into the operator precedence languages family (OPL), created by R. Floyd [1], which is used for efficient bottom-up parsing [2,3]. The author’s inspiration from the structure of arithmetic expressions, where precedence is assigned to multiplicative operators (∗ and /) over additive operators (+ and −), is a key insight. Through the process of bottom-up parsing, the left side (non-terminal symbol) completely replaces the identified right-side production (body) in a context-free grammar (CFG), leaving no room for ambiguity. Operator precedence was extended to grammars that consist of terminals on the right side, even if non-terminals separated them. A CFG is generally considered an operator precedence grammar (OPG) if it does not contain productions with adjacent non-terminal symbols on its right-hand side.

OPLs have greatly aided in inferring context-free grammars. An example is described in [4,5,6], where a method is presented for inferring operator precedence-free grammars from bracketed samples. The method is based on constructing parse trees and utilizing functions that produce the grammars. Precedence rules are used to identify the brackets surrounding the terminal elements of a string in the sample, indicating the order in which the string should be evaluated.

Research on input-driven formal languages (IDL) [7,8,9] (later renamed as Visibly Pushdown Languages (VPL) [10]) has concluded [11] that OP closure properties imply ID closure properties and that ID languages are a specific type of OP languages characterized by limited OP relations [12].

Since the advancements in parallel computing, local parsability properties derived from OPL have been utilized to generate fast parallel parsers [13].

This paper’s main contribution is its novel approach to building precedence relationships between terminal symbols in non-OPGs. This approach allows the generation of operator precedence tables and bottom-up parsing on a string derived by the non-OPG with support from the table obtained. The novelty of the work is a significant aspect that sets it apart from previous research in the field.

• The sets of Left and Right terminals proposed in previous works [1,11,14] to build precedence relationships between the terminals of an OPG were redefined.
• A new set of terminals called Leftmost was defined to support solving precedence relationships when there are two or more adjacent terminals on the right side of the productions. This set is significant as it systematically handles the precedence relationships in such complex scenarios, expanding the bottom-up parsing process with non-OPGs.
• An algorithm was established to build the precedence table with the support of the three sets of terminals proposed.
• Finally, applying the proposed algorithms makes it possible to obtain from a non-OPG the relations and operator precedence table previously limited to OPGs only. In addition, a bottom-up operator-precedence parser could be used to parse any string generated by a non-OPG, a technique that could only be applied to OPGs.

As demonstrated in this work, the proposed solution to construct the operator precedence table is not just a theoretical concept but a practical tool that can be applied to OPGs without any restrictions. At the end of the work, the functionality is demonstrated by applying it to an OPG and two non-OPGs and carrying out the respective bottom-up parsing. This practical demonstration should instill confidence in the effectiveness of the proposed solution and ensure its practical applicability.

The paper is organized as follows: Section 2 provides the necessary definitions to understand this work. Section 3 presents the previous work carried out in the area of CFG. Section 4 introduces our approach, detailing the problem we aim to solve and the redefinitions of previous works’ concepts used to develop our algorithms. Section 5 presents examples of applying the proposed algorithm to one OPG and two non-OPGs, demonstrating the application of bottom-up parsing with the precedence tables to test their use. Section 6 describes several exceptions where the rules described in the proposed algorithms do not apply. Finally, Section 7 provides conclusions to our work.

2. Basic Definitions

2.1. Context-Free Grammars and Languages

Within Chomsky’s hierarchy [15], context-free grammars play a significant role in programming and compilation language applications by addressing the syntactic structure of programming languages.

A context-free grammar (CFG) G generates a language $L\left(G\right)$, commonly called context-free language (CFL), which is composed of the strings generated by the CFG. The CFG is defined as a 4-tuple $G\left(S\right)=<T,N,S,P>$, where:

• T represents the set of terminal symbols that create the strings within the CFL generated by the CFG.
• N represents the set of non-terminal symbols or syntactic variables that determine strings leading to CFL generation.
• S is the initial non-terminal symbol from which all strings defined by the GFC are generated.
• P is the set of productions or rules that group terminals and non-terminals to generate the strings. A production takes the form $A⟶\alpha$, where A represents a non-terminal and $\alpha$ is a combination of terminals and non-terminals. The ⟶ is pronounced “produce”. Thus, the production is read “A produce alpha”.

The following notation will be used: lowercase letters from the beginning of the alphabet represent terminal symbols $(a,b,c,\dots \in T)$; uppercase letters from the beginning of the alphabet represent non-terminal symbols $(A,B,C,\dots \in N)$; lowercase letters late in the alphabet represent terminal strings $(u,v,w,x,y,z\in T^{+})$; lowercase Greek letters generally represent terminal and/or non-terminal strings $(\alpha ,\beta ,\gamma ,\dots \in {(T\cup N)}^{\ast })$, and the empty string will be represented by $\epsilon$ (this Greek letter will be the exception to the above convention).

2.2. Operator Precedence Grammars (Basic Rule)

A CFG is considered an operator grammar if none of the productions in P have adjacent non-terminal symbols on their right side. In other words, for a production $A⟶\alpha$ in G, $\alpha$ does not take the form $uBCv$.

2.3. Derivations

A string $\eta \in {(T\cup N)}^{\ast }$ can be derived in k steps from a non-terminal $A\in N$ if there exists a sequence of strings of the form ${\eta }_1,{\eta }_2,\dots ,{\eta }_k$. Using the symbol ⟹, meaning one-step derivation, the sequence of strings is arranged in the form: ${\eta }_1⟹{\eta }_2⟹\dots ⟹{\eta }_k$.

In this sequence, ${\eta }_1$ corresponds to A and ${\eta }_k$ to $\eta$. Each intermediate ${\eta }_i$ in the sequence has the form $\delta B\gamma$, where $B\in N$ and there is a production $B⟶\beta$, such that by substituting it on the right side, ${\eta }_{i+1}(=\delta \beta \gamma )$ is obtained. The derivation in one or more steps is denoted with the operator $\stackrel{+}{⟹}$. In general, it is stated that every string of terminal symbols $w\in L\left(G\right)$ can be established as $S\stackrel{+}{⟹}w$ or expanding the derivation in one or more steps: $S={\eta }_1⟹{\eta }_2⟹\dots ⟹{\eta }_k=w$. For a grammar G, a sentential form $\eta \in {(T\cup N)}^{\ast }$ is a string that $S\stackrel{\ast }{⟹}\eta$, meaning that $\eta$ can be obtained with zero or more derivations from S. If two grammars generate identical languages, they are considered equivalent.

2.4. Types of Derivations

According to [16], $S={\eta }_1⟹{\eta }_2⟹\dots ⟹{\eta }_k=w$ is a leftmost derivation of the string $w\in T^{\ast }$, when each ${\eta }_i,2\le i\le k-1$, has the form $x_i{A}_i{\beta }_i$ with $x_i\in T^{\ast }$, $A_i\in N$ and ${\beta }_i\in {(T\cup N)}^{\ast }$. Furthermore, $A_i⟶{\alpha }_i$ belongs to P, and then, in each ${\eta }_i$, the symbol $A_i$ is substituted by ${\alpha }_i$, resulting in the sentential form ${\eta }_{i+1}$. Each ${\eta }_i$ is called the left-sentential form.

If each ${\eta }_i,2\le i\le k-1$, takes the form of ${\beta }_i{A}_i{x}_i$ with $x_i\in T^{\ast }$, $A_i\in N$, and ${\beta }_i\in {(T\cup N)}^{\ast }$, then a rightmost derivation would be formed. Each ${\eta }_i$ is called the right-sentential form.

2.5. Parse Trees

According to reference [16], a derivation tree for a CFG $G\left(S\right)=<T,N,S,P>$ is a labeled and ordered tree in which each node receives a label corresponding to a symbol from the set $N\cup T\cup \left\{\epsilon \right\}$. If a non-leaf node is labeled A and its immediate descendants are labeled $X_1,X_2,\dots ,X_n$, then $A⟶X_1{X}_2\dots X_n$ is a production in P. A labeled ordered tree D is a derivation tree for a CFG $G\left(A\right)=<T,N,A,P>$ if

• The root of D is labeled A.
• If $D_1,\dots ,D_k$ are the subtrees of the direct descendants of the root and the root of $D_i$ is labeled $X_i$, then $A⟶X_1\dots X_k$ is in P.
• $D_i$ is a derivation tree for $G\left(X_i\right)=<T,N,X_i,P>$ if $X_i$ is in N or $D_i$ is a single node labeled $X_i$ if $X_i$ is in T or $D_i$ is a single node labeled $\epsilon$.

Parse trees can be constructed from any derivation type.

2.6. Bottom-Up Parsing

The bottom-up parsing syntax analysis [2], also known as shift-reduce parsing, attempts to build a parsing tree for an input string that starts in the leaves (tree bottom) and moves to the root (tree top). This process is considered as the reduction of the string w to the initial symbol S of a CFG. At each step of parsing reduction, a particular substring of the sentential form that matches the right side of a production is replaced by the non-terminal symbol of the left side of that production. If, at each step, the substring is chosen correctly, a rightmost derivation is traced out inversely.

2.7. Handle

A handle [2,17] of a right-sentential form $\gamma$ is a production $A⟶\beta$ and a position of $\gamma$ where the string $\beta$ could be found and replaced by A to produce the previous right-sentential form in a rightmost derivation of $\gamma$. Generally, if $S\stackrel{\ast }{⟹}\alpha Aw⟹\alpha \beta w$, then $A⟶\beta$ if the position next to $\alpha$ is a handle of $\alpha \beta w$. If the grammar is ambiguous, more than one handle will be obtained. If the grammar is unambiguous, then every right-sentential form has exactly one handle. Usually, the string $\beta$ is told to be a handle of $\alpha \beta w$ when the conditions for doing so are clear.

2.8. Implementation of a Bottom-Up Parsing

The bottom-up parsing by shift and reduction uses a stack to store grammar symbols and a buffer to handle the input string to be analyzed. The $ symbol is also used to delimit the bottom of the stack and the right side of the input buffer. The recognition model format starts with the stack at $ and the string $w\$$ in the input, as shown in

Table 1. Bottom-up parsing table.

Stack	Input	Action
$	$w\$$
⋯	⋯	Shift/Reduce
⋯	⋯	Shift/Reduce
$\$S$	$	Accept

.

The bottom-up parsing shifts zero or more input symbols to the stack until a handle is at the top. The parsing then reduces the handle to the left side of the appropriate production to obtain the sentential form corresponding to the previous step of the rightmost derivation. When reducing, the parsing recognizes that the right end of the handle is at the top of the stack. Therefore, the parsing takes action to find its left end in the stack and determine the non-terminal that will replace it according to the right side of some production where it matches the handle. These steps are repeated until an error is detected or until the stack contains $\$S$ and the input is with the symbol $, at which point the parsing ends and the input string is considered valid for the CFG.

3. Previous Work

According to [1,11,14], for a CFG G, the left terminal sets ${\mathcal{L}}_G\left(A\right)$ and right terminal sets ${\mathcal{R}}_G\left(A\right)$ are defined as follows:

$${\mathcal{L}}_G\left(A\right)=\left\{a|A\stackrel{\ast }{⟹}\gamma a\alpha ,\gamma \in N\cup \left\{\epsilon \right\}\right\}.$$

$${\mathcal{R}}_G\left(A\right)=\left\{a|A\stackrel{\ast }{⟹}\alpha a\gamma ,\gamma \in N\cup \left\{\epsilon \right\}\right\}.$$

Precedence relationships arise from the parse tree’s establishment of binary relationships between consecutive terminals or those that become sequential after a bottom-up process toward the non-terminal symbol S.

The precedence relationships are established as follows:

• $a\doteq b$, if and only if $\exists A⟶\alpha a\gamma b\beta \in P,\gamma \in N\cup \left\{\epsilon \right\}$.
• $a⋖b$, if and only if $\exists A⟶\alpha aD\beta \in P,b\in {\mathcal{L}}_G\left(D\right)$.
• $a⋗b$, if and only if $\exists A⟶\alpha Db\beta \in P,a\in {\mathcal{R}}_G\left(D\right)$.

According to [2], precedence relations are used to delimit a handle in a right-sentential form. That is, in the sentential form $\alpha \beta w$, the substring $\beta$ is a handle if there is a production $A⟶\beta$ in the CFG; therefore, it can be delimited by the precedence relations, obtaining $\alpha ⋖\beta ⋗w$. The relation ≐ between the symbols used when the handle has more than one consecutive terminal symbol. That is, if $\beta =a_1{a}_2\dots a_n$, then the relation $a_i\doteq a_{i+1},\forall i=1,\dots ,n-1$ should be established. Suppose a right-sentential form is $A_0{a}_1{A}_1{a}_2\dots a_n{A}_n$, where each $A_i$ is a non-terminal. In that case, the relations can be established as $a_i⋖A_i{a}_{i+1}$, with a maximum of one non-terminal (operator grammar principle) between the terminals. Non-terminals could be eliminated in the right sentential form, leaving only the relationships between terminals.

In short, each time a handle is obtained, it can be enclosed between the symbols of ⋖ and ⋗. In addition, two consecutive terminal symbols can be inside a handle (non-terminals in the middle), and the relationship is to be established ≐. Finally, non-terminal symbols can be removed from the right-sentential form when a handle is found and locked between the precedence relations.

According to [2], the concepts discussed in Section 2.8, and the precedence relations, the precedence parsing Algorithm 1 is constructed as follows:

Algorithm 1 Precedence parsing algorithm

Require: Set of precedence relations. procedure PrecedenceParsing(w)   $stack\leftarrow \left[\$\right]$   $end\leftarrow false$   $pos\leftarrow 0$   do     $a\leftarrow stack\left[top\right]$     $b\leftarrow w\$\left[pos\right]$     if $a=\$$ and $b=\$$ then       $\mathtt{print}$(“Action: Accept”)       $end\leftarrow true$     else       if $a⋖b$ or $a\doteq b$ then         $pos++$         $\mathtt{push}(stack,b)$         $\mathtt{print}$(“Action: Shift”)       else         if $a⋗b$ then           do             $e\leftarrow \mathtt{pull}\left(stack\right)$           while not $\left(stack\right[top]⋖e)$           $\mathtt{print}$(“Action: Reduce”)         else           $\mathtt{print}$(“Action: Error”)           $end\leftarrow true$         end if       end if     end if   while not $end$ end procedure

4. Approach

This work proposes a redefinition of the Left and Right terminal sets, corresponding to ${\mathcal{L}}_G\left(A\right)$ and ${\mathcal{R}}_G\left(A\right)$, respectively. Additionally, the definition of the new Leftmost set is presented. The new rules for determining precedence relations are demonstrated even if the CFG does not comply with the fundamental rule of operator grammar, meaning that the CFG can have more than one adjacent non-terminal symbol on the right side of its productions.

We present the algorithms for constructing the three proposed sets: Left, Leftmost, and Right. Additionally, we demonstrate the algorithm that incorporates the newly established precedence rules.

4.1. Definitions

There are the following symbols:

• A string of terminals $x\in T^{+}$.
• A string of non-terminals $\beta \in N^{\ast }$.
• A sentential form $\gamma \in {(T\cup N)}^{\ast }$.

The following sets are defined:

• The left, denoted as $\mathcal{L}\left(A\right)$, is the set of terminal symbols that can appear on the left side of any sentential form as a product of a rightmost derivation from A.

  $$\mathcal{L}\left(A\right)=\{a\in T|A\stackrel{\ast }{⟹}\beta a\gamma \}.$$
• The leftmost, denoted as ${\mathcal{L}}_m\left(A\right)$, is the set of terminal symbols that can appear at the end of the left side in any derivation from A, in the absence of other leftmost grammatical symbols (or that derive to $\epsilon$ in their absence).

  $${\mathcal{L}}_m\left(A\right)=\{a\in T|A\stackrel{\ast }{⟹}a\gamma \}.$$
• The right, denoted as $\mathcal{R}\left(A\right)$, is the set of terminal symbols that can appear at the right end of the rightmost derivations from A or appear further to the right in any production of A.

  $$\mathcal{R}\left(A\right)=\{a\in T|A\stackrel{\ast }{⟹}\gamma a\vee A⟶\gamma a\beta \}.$$

According to the above, the following precedence rules are defined:

• If $C⟶{\gamma }_{1}a\beta B{\gamma }_2,b\in \mathcal{L}\left(B\right)$, then $a⋖b$.
• If $C⟶{\gamma }_{1}A\beta B{\gamma }_2,a\in \mathcal{R}\left(A\right)\wedge b\in {\mathcal{L}}_m\left(B\right)\wedge \beta \stackrel{\ast }{⟹}\epsilon$, then $a⋗b$.
• If $C⟶{\gamma }_{1}A\beta b{\gamma }_2,a\in \mathcal{R}\left(A\right)\wedge \beta \stackrel{\ast }{⟹}\epsilon$, then $a⋗b$.
• If $C⟶{\gamma }_{1}a\beta b{\gamma }_2$, then $a\doteq b$.

4.2. Problem Analysis

4.2.1. Absolute Operator Grammar

Given the rightmost derivation series of the form:

$$S\stackrel{+}{⟹}{\gamma }_{1}A{x}_1⟹{\gamma }_1{\omega }_1{x}_1, \mathrm{where} A⟶{\omega }_1 \mathrm{and} {\omega }_1={\gamma }_{2}B{\gamma }_3.$$

(1)

It is noted that ${\omega }_1$ is a handle according to the previous definition in Section 2.7.

The right-sentential form of (1) can be rewritten as follows:

$${\gamma }_1{\omega }_1{x}_1={\gamma }_1{\gamma }_{2}B{\gamma }_3{x}_1\stackrel{+}{⟹}{\gamma }_1{\gamma }_{2}B{x}_2{x}_1⟹{\gamma }_1{\gamma }_2{\omega }_2{x}_2{x}_1, \mathrm{where} B⟶{\omega }_2.$$

(2)

From the last sentential form in (2), it follows that ${\omega }_2$ is a handle according to the definition in Section 2.7.

Because of the above, the analysis will focus on the productions born of A, which have at least one non-terminal B on the right, as seen in (1). The productions in A will be traversed through grammar to find the relations of precedence of non-terminal B located on the right side.

Within the context of ${\omega }_1$, having to $B⟶{\omega }_2$, and ${\omega }_2$ is a handle, the following forms can be obtained from its definition in (1):

(a)

${\omega }_1={\gamma }_{4}aB$, it follows that $a⋖\mathcal{L}\left(B\right)$. Here ${\gamma }_2={\gamma }_{4}a$ and ${\gamma }_3=\epsilon$.

(b)

${\omega }_1=Bb{\gamma }_5$, it follows that $\mathcal{R}\left(B\right)⋗b$. Here ${\gamma }_2=\epsilon$ and ${\gamma }_3=b{\gamma }_5$.

(c)

${\omega }_1={\gamma }_{4}aBb{\gamma }_5$, it follows that $a⋖\mathcal{L}\left(B\right)$ and $\mathcal{R}\left(B\right)⋗b$. Here ${\gamma }_2={\gamma }_{4}a$ and ${\gamma }_3=b{\gamma }_5$.

For the non-terminal start symbol, S, an initial dummy production is defined $E⟶\$S\$$ and rule (c) is applied.

For a production $A⟶{\gamma }_{1}aXb{\gamma }_2,X\in N\cup \left\{\epsilon \right\}$, it follows that $a\doteq b$.

4.2.2. General Grammar with Two or More Consecutive Non-Terminal Symbols

Redefinition of Left, Right and definition of Leftmost.

• Left(B):

Given the rightmost derivation:

$${\gamma }_{1}aB{x}_1⟹{\gamma }_{1}a{\omega }_1{x}_1.$$

(3)

It is observed that ${\omega }_1$ is a handle within a bottom-up parsing (inverse rightmost derivation) since $B⟹{\omega }_1$; therefore, from (3), it can be established that ${\gamma }_{1}a⋖{\omega }_1⋗x_1$. In addition, ${\omega }_1$ can have the following forms:

(a)

${\omega }_1={\beta }_{1}b{\gamma }_2$.

(b)

${\omega }_1={\beta }_{1}C{\gamma }_3$.

Continuing with the rightmost derivation in (3) and taking each of the options of ${\omega }_1$, we obtain that:

(a)

${\gamma }_{1}aB{x}_1⟹{\gamma }_{1}a{\beta }_{1}b{\gamma }_2{x}_1$ since ${\omega }_1$ is a handle, consequently ${\gamma }_{1}a⋖{\beta }_{1}b{\gamma }_2⋗x_1$; therefore, $a⋖b$ where $B⟶{\beta }_{1}b{\gamma }_2$ and $b\in \mathcal{L}\left(B\right)$.

(b)

${\gamma }_{1}aB{x}_1⟹{\gamma }_{1}a{\beta }_{1}C{\gamma }_3{x}_1\stackrel{\ast }{⟹}{\gamma }_{1}a{\beta }_{1}C{x}_2{x}_1\stackrel{\ast }{⟹}{\gamma }_{1}a{\beta }_1{\beta }_{2}D{x}_3{x}_2{x}_1⟹{\gamma }_{1}a{\beta }_1{\beta }_2{\beta }_{3}b{\gamma }_4{x}_3{x}_2{x}_1$. It is observed that $C\stackrel{+}{⟹}{\beta }_{2}D{x}_3$ and $D⟶{\beta }_{3}b{\gamma }_4$; therefore, ${\beta }_{3}b{\gamma }_4$ is a handle, and consequently ${\gamma }_{1}a{\beta }_1{\beta }_2⋖{\beta }_{3}b{\gamma }_4⋗x_3{x}_2{x}_1$ and $a⋖b$.

In short, ${\gamma }_{1}aB{x}_1\stackrel{+}{⟹}{\gamma }_{1}a{\beta }_1{\beta }_2{\beta }_{3}b{\gamma }_4{x}_3{x}_2{x}_1$; taking $\beta ={\beta }_1{\beta }_2{\beta }_3$ and ${\gamma }_5={\gamma }_4{x}_3{x}_2$, we obtain the summary derivation ${\gamma }_{1}aB{x}_1\stackrel{+}{⟹}{\gamma }_{1}a\beta b{\gamma }_5{x}_1$, where $B\stackrel{+}{⟹}\beta b{\gamma }_5$ and $b\in \mathcal{L}\left(B\right)$.

• Right(B):

Given the rightmost derivation:

$${\gamma }_{1}Ba{x}_1⟹{\gamma }_1{\omega }_{1}a{x}_1.$$

(4)

It is observed that ${\omega }_1$ is a handle within a bottom-up parsing (inverse rightmost derivation), since $B⟹{\omega }_1$; therefore, from (4), it can be established that ${\gamma }_1⋖{\omega }_1⋗a{x}_1$. In addition, ${\omega }_1$ can have the following forms:

(a)

${\omega }_1={\gamma }_{2}b\beta$.

(b)

${\omega }_1={\gamma }_{3}C{\beta }_1,{\beta }_1\stackrel{\ast }{⟹}\epsilon$.

Continuing with the rightmost derivation in (4) and taking each of the options of ${\omega }_1$, we obtain that:

(a)

${\gamma }_{1}Ba{x}_1⟹{\gamma }_1{\gamma }_{2}b\beta a{x}_1$ since ${\omega }_1$ is a handle, consequently ${\gamma }_1⋖{\gamma }_{2}b\beta ⋗a{x}_1$; therefore, $b⋗a$ where $B⟶{\gamma }_{2}b\beta$ and $b\in \mathcal{R}\left(B\right)$.

(b)

${\gamma }_{1}Ba{x}_1⟹{\gamma }_1{\gamma }_{3}C{\beta }_{1}a{x}_1\stackrel{\ast }{⟹}{\gamma }_1{\gamma }_3{\gamma }_{4}Da{x}_1⟹{\gamma }_1{\gamma }_3{\gamma }_4{\gamma }_{5}b{\beta }_{2}a{x}_1$. It is noted that $C\stackrel{+}{⟹}{\gamma }_{4}D$ and $D⟶{\gamma }_{5}b{\beta }_2$; therefore, ${\gamma }_{5}b{\beta }_2$ is a handle, and consequently, ${\gamma }_1{\gamma }_3{\gamma }_4⋖{\gamma }_{5}b{\beta }_2⋗a{x}_1$ and $b⋗a$.

In short, ${\gamma }_{1}Ba{x}_1\stackrel{+}{⟹}{\gamma }_1{\gamma }_3{\gamma }_4{\gamma }_{5}b{\beta }_{2}a{x}_1$; taking ${\gamma }_6={\gamma }_3{\gamma }_4{\gamma }_5$, we obtain the summary derivation ${\gamma }_{1}Ba{x}_1\stackrel{+}{⟹}{\gamma }_1{\gamma }_{6}b{\beta }_{2}a{x}_1$, where $B\stackrel{+}{⟹}{\gamma }_{6}b{\beta }_2$ and $b\in \mathcal{R}\left(B\right)$.

• Leftmost(B):

Given the production with two non-terminal symbols on the right (body):

$$S⟶AB$$

(5)

$$A⟶{\gamma }_1{b}_1{\beta }_1$$

(6)

Rightmost derivation from S in (5) is:

$$\begin{array}{ccccccccccccc}S& ⟹& AB& \stackrel{+}{⟹}& Aa\gamma & \stackrel{+}{⟹}& Aa{x}_1& ⟹& {\gamma }_1{b}_1{\beta }_{1}a{x}_1& =& {\gamma }_{2}Ca{x}_1& \stackrel{+}{⟹}& {\gamma }_2{\gamma }_3{\gamma }_4{b}_2{\beta }_{2}a{x}_1\\ \left(i\right)& & \left(ii\right)& & \left(iii\right)& & \left(iv\right)& & \left(v\right)& & \left(vi\right)& & \left(vii\right)\end{array}.$$

In summary:

• In $\left(v\right)$, the relationship $⋖{\gamma }_1{b}_1{\beta }_1⋗a{x}_1$ can be established since the right part of the production (6) is a handle. Therefore, $b_1⋗a$ and $b_1\in \mathcal{R}\left(A\right)$.
• In $\left(vi\right)$, it is known that ${\beta }_1=C_0{C}_1\dots C_{n}C$, where each $C_i\in N$ and C is the non-terminal, first derived from the right. It is noted that ${\gamma }_2={\gamma }_1{b}_1{C}_0\dots C_n$.
• In $\left(vii\right)$, $C\stackrel{+}{⟹}{\gamma }_3{\gamma }_4{b}_2{\beta }_2$ being ${\gamma }_4{b}_2{\beta }_2$ the result of the last rightmost derivation performed and, in turn, a handle; therefore, the relationship ${\gamma }_2{\gamma }_3⋖{\gamma }_4{b}_2{\beta }_2⋗a{x}_1$ is established, since ${\gamma }_4{b}_2{\beta }_2$ is a handle, therefore, $b_2⋗a$.
• From $\left(iv\right)$, $Aa{x}_1\stackrel{+}{⟹}{\gamma }_2{\gamma }_3{\gamma }_4{b}_2{\beta }_{2}a{x}_1$. Establishing ${\gamma }_5={\gamma }_2{\gamma }_3{\gamma }_4$, then $A\stackrel{+}{⟹}{\gamma }_5{b}_2{\beta }_2$, therefore, $b_2\in \mathcal{R}\left(A\right)$.
• From $\left(ii\right)$, $B\stackrel{+}{⟹}a\gamma$ is established, from which we define the new Leftmost set of B as ${\mathcal{L}}_m\left(B\right)=\{a\in T|B\stackrel{+}{⟹}a\gamma \}$.

4.2.3. An Intuitive Way to Observe the Elements of Each Set

• Vision of Left(·):
• Given the CFG:
• $A⟶CDE$
• $E⟶eh$
• $D⟶d$
• $C⟶cF$
• $F⟶f$

The rightmost derivation of the string $cfdeh$ carries the following way of creating the $Left\left(A\right)$ or $\mathcal{L}\left(A\right)$.

$$\begin{array}{ccccccccccc}A& ⟹& CDE& ⟹& CD\mathbf{e}h& ⟹& C\mathbf{d}eh& ⟹& \mathbf{c}Fdeh& ⟹& c\mathbf{f}deh\\ & & ⋖& & e& & d& & c& & \end{array}.$$

The terminal symbols e, d, and c are viewed from the left and recorded in $\mathcal{L}\left(A\right)$. The symbol e is the first one seen from the left and is recorded in $\mathcal{L}\left(A\right)$, and the symbol h is blocked by e since both appear when E is substituted. Then, D is replaced by d, which is observed and recorded in $\mathcal{L}\left(A\right)$. When $cF$ replaces C, we observe and record c in $\mathcal{L}\left(A\right)$. Finally, when the substitution of F by f is carried out, it can no longer be observed (blocked by c) and cannot be registered. Consequently:

$$\mathcal{L}\left(A\right)=\{e,d,c\}.$$

• Vision of Right(·):
• Given the CFG:
• $A⟶abBC$
• $B⟶eF$
• $C⟶cD$
• $D⟶d$
• $F⟶f$

The rightmost derivation of the string $abefcd$ carries the following way of creating the $Right\left(A\right)$ or $\mathcal{R}\left(A\right)$.

$$\begin{array}{ccccccccccc}A& ⟹& a\mathbf{b}BC& ⟹& abB\mathbf{c}D& ⟹& abBc\mathbf{d}& ⟹& ab\mathbf{e}Fcd& ⟹& abe\mathbf{f}cd\\ & & b& & c& & d& & & & ⋗\end{array}.$$

The terminal symbols b, c, and d are viewed from the right and recorded in $\mathcal{R}\left(A\right)$. The symbol b is the first one observed and recorded in $\mathcal{R}\left(A\right)$. The symbol a is blocked by b, since both appear when A is derived. C is then replaced by $cD$ and c is observed and recorded in $\mathcal{R}\left(A\right)$. When D is substituted for d, we observe and record d in $\mathcal{R}\left(A\right)$. Then B is derived by $eF$ but e cannot be recorded since the previous inclusion of c and d in $\mathcal{R}\left(A\right)$ makes it invisible or blocks it from being observed from the right. Finally, when substituting F for f, it cannot be observed from the right either (blocked by c and d) and cannot be recorded. Consequently:

$$\mathcal{R}\left(A\right)=\{b,c,d\}.$$

• Vision of Leftmost(·):
• Given the CFG:
• $S⟶dAB$
• $A⟶fa$
• $B⟶Cb$
• $C⟶c$

The rightmost derivation of the string $dfacb$ carries the following way of creating the $Leftmost\left(B\right)$ or ${\mathcal{L}}_m\left(B\right)$, as shown in Figure 1.

It can be seen that $\mathcal{L}\left(B\right)=\{b,c\}$. When B derivates $Cb$, we observe that ${\mathcal{L}}_m\left(B\right)=\left\{b\right\}$ because no more terminal symbols are seen up to that point. In the following derivation, C is replaced by c; therefore, c is located further to the left of the substring $cb$, leaving ${\mathcal{L}}_m\left(B\right)=\left\{c\right\}$.

4.2.4. Summary of Relations between Grammatical Symbols from Productions and Sets

Table 2. General productions and precedence relationships obtained.

Producing	Relationship
$A⟶a\beta b$	$a\doteq b$
$A⟶C\beta b,\beta \stackrel{\ast }{⟹}\epsilon$	$\mathcal{R}\left(C\right)⋗b$
$A⟶a\beta C$	$a⋖\mathcal{L}\left(C\right)$
$A⟶B\beta C,\beta \stackrel{\ast }{⟹}\epsilon$	$\mathcal{R}\left(B\right)⋗{\mathcal{L}}_m\left(C\right)$

shows the relationships between the grammatical symbols of the productions and the sets of terminals.

4.3. Algorithms

The following algorithms were developed based on the definitions presented in Section 4.1.

Algorithm 2 receives a non-terminal A whose productions are known; for each of these, it is verified whether they correspond to the form $\beta B\gamma$; if so, Algorithm 2 is executed again, sending the non-terminal B as a parameter (provided that $B\ne A$), and its response is included in the set $\mathcal{L}\left(A\right)$.

Subsequently, it is verified whether the production corresponds to the form $\beta a\gamma$, and if so, the terminal a is added to the set $\mathcal{L}\left(A\right)$.

Once the verification of all productions of A is completed, the set $\mathcal{L}\left(A\right)$ is returned as the output of Algorithm 2.

Algorithm 2 $\mathtt{Left}$ algorithm of a non-terminal A

function Left(A)   $\mathcal{L}\left(A\right)\leftarrow \varnothing$   for each production of A do     if $A⟶\beta B\gamma$ then       $\mathcal{L}\left(A\right)\supseteq \mathtt{Left}\left(B\right)$ // $\mathcal{L}\left(A\right)$ contains a $\mathtt{Left}\left(B\right)$     end if     if $A⟶\beta a\gamma$ then       $a\in \mathcal{L}\left(A\right)$ // a is in $\mathcal{L}\left(A\right)$     end if   end for   return $\mathcal{L}\left(A\right)$ end function

Algorithm 3 receives a non-terminal A whose productions are known; for each of these, it is verified if they correspond to the form $\beta B\gamma$ and $\beta \stackrel{\ast }{⟹}\epsilon$; if so, Algorithm 3 is executed again, sending the non-terminal B as a parameter (provided that $B\ne A$), and its response is included in the set ${\mathcal{L}}_m\left(A\right)$.

Subsequently, it is verified if the production corresponds to the form $\beta a\gamma$ and $\beta \stackrel{\ast }{⟹}\epsilon$. If so, the terminal a is added to the set ${\mathcal{L}}_m\left(A\right)$.

Once the verification of all productions of A is completed, the set ${\mathcal{L}}_m\left(A\right)$ is returned as the output of Algorithm 3.

Algorithm 3 $\mathtt{Leftmost}$ algorithm of a non-terminal A

function Leftmost(A)   ${\mathcal{L}}_m\left(A\right)\leftarrow \varnothing$   for each production of A do     if $A⟶\beta B\gamma$ and $\beta \stackrel{\ast }{⟹}\epsilon$ then       ${\mathcal{L}}_m\left(A\right)\supseteq \mathtt{Leftmost}\left(B\right)$     end if     if $A⟶\beta a\gamma$ and $\beta \stackrel{\ast }{⟹}\epsilon$ then       $a\in {\mathcal{L}}_m\left(A\right)$     end if   end for   return ${\mathcal{L}}_m\left(A\right)$ end function

Algorithm 4 receives a non-terminal A whose productions are known; for each of these, it is verified if they correspond to the form $\gamma B\beta$ and $\beta \stackrel{\ast }{⟹}\epsilon$; if so, Algorithm 4 is executed again, sending the non-terminal B as a parameter (provided that $B\ne A$) and its response is included in the set $\mathcal{R}\left(A\right)$.

Subsequently, it is verified whether the production corresponds to the form $\gamma a\beta$, and if so, the terminal a is added to the set $\mathcal{R}\left(A\right)$.

Once all productions of A have been verified, the set $\mathcal{R}\left(A\right)$ is returned as the output of Algorithm 4.

Algorithm 4 $\mathtt{Right}$ algorithm of a non-terminal A

function Right(A)   $\mathcal{R}\left(A\right)\leftarrow \varnothing$   for each production of A do     if $A⟶\gamma B\beta$ and $\beta \stackrel{\ast }{⟹}\epsilon$ then       $\mathcal{R}\left(A\right)\supseteq \mathtt{Right}\left(B\right)$     end if     if $A⟶\gamma a\beta$ then       $a\in \mathcal{R}\left(A\right)$     end if   end for   return $\mathcal{R}\left(A\right)$ end function

Algorithm 5 receives a grammar $G\left(S\right)=<T,N,S,P>$ and Algorithms 2–4. Initially, precedence relations are added between the delimiting symbol $ and the Left and Right sets of the non-terminal symbol of start S, according to rules (A.1) and (A.2), respectively.

Algorithm 5 operates in an iterative manner. It traverses all the productions of the set P, and for each iteration, it initializes two temporary variables, u and l, to null and an empty list, respectively. It then performs a series of processes for each pair of contiguous grammatical symbols X and Y in a production.

• The algorithm checks if $XY$ has the form $ab$; if so, it adds the corresponding precedence relationship between a and b, following rule (B).
• The algorithm checks if $XY$ has the form $aB$; if so, it assigns u the value of a and adds the corresponding precedence relations between a and terminals in $\mathtt{Left}\left(B\right)$, following rule (C).
• The algorithm checks if $XY$ has the form $Ab$; if so, it adds the corresponding precedence relations between b and terminals in $\mathtt{Right}\left(A\right)$, following rule (D.1). Then, check if $u\ne null$, and if so, add the corresponding precedence relationship between u and b, following rule (D.2), and reset u to $null$. Finally, checks if list l has elements, and if so, adds the corresponding precedence relations between b and terminals in $\mathtt{Right}\left(B\right)$, following rule (D.3), and resets list l to empty.
• The algorithm checks if $XY$ has the form $AB$; if so, it adds the corresponding precedence relations between terminals in $\mathtt{Right}\left(A\right)$ and terminals in $\mathtt{Leftmost}\left(B\right)$, following rule (E.1). Then, it checks if $u\ne null$, and if so, adds the corresponding precedence relation between u and terminals in $\mathtt{Left}\left(B\right)$, following rule (E.2). Finally, it checks if the list l has elements and if so, adds the corresponding precedence relations between terminals in $\mathtt{Right}\left(C\right)$, with $C\in l$ and terminals in $\mathtt{Leftmost}\left(B\right)$, following rule (E.3), and resets the list l if necessary.

Algorithm 5 Algorithm to obtain the operator precedence table of a G grammar

Require: $G\left(S\right)=<T,N,S,P>$ procedure Table($G, \mathtt{Left}(·), \mathtt{Right}(·), \mathtt{Leftmost}(·)$)   compute $\mathtt{Left}\left(A\right), \mathtt{Right}\left(A\right), \mathtt{Leftmost}\left(A\right), \forall A\in N$   add $\$⋖a,\forall a\in \mathtt{Left}\left(S\right)$      (A.1)   add $a⋗\$,\forall a\in \mathtt{Right}\left(S\right)$      (A.2)   for each $A⟶\gamma$ in P do     $u\leftarrow null$     $l\leftarrow \left[\right]$ // empty list     for each $XY$ contiguous in $\gamma$ do       if $XY=ab$ then         add $a\doteq b$      (B)       end if       if $XY=aB$ then         $u\leftarrow a$         add $a⋖b,\forall b\in \mathtt{Left}\left(B\right)$      (C)       end if       if $XY=Ab$ then         add $a⋗b,\forall a\in \mathtt{Right}\left(A\right)$      (D.1)         if $u\ne null$ then           add $u\doteq b$      (D.2)           $u\leftarrow null$         end if         if $l\ne \left[\right]$ then           for $B\in l$ do             add $a⋗b,\forall a\in \mathtt{Right}\left(B\right)$      (D.3)           end for           $l\leftarrow \left[\right]$         end if       end if       if $XY=AB$ then         add $a⋗b,\forall a\in \mathtt{Right}\left(A\right)\wedge \forall b\in \mathtt{Leftmost}\left(B\right)$      (E.1)         if $u\ne null$ then           add $u⋖b,\forall b\in \mathtt{Left}\left(B\right)$      (E.2)         end if         if $l\ne \left[\right]$ then           for $C\in l$ do             add $c⋗b,\forall c\in \mathtt{Right}\left(C\right)\wedge \forall b\in \mathtt{Leftmost}\left(B\right)$      (E.3)           end for         end if         if $B\stackrel{\ast }{⟹}\epsilon$ then           add A to l         else           $l\leftarrow \left[\right]$         end if       end if     end for   end for end procedure

4.4. Complexity Analysis

The following variables will be established for the computation of the complexity of the four proposed algorithms:

• t: Cardinality of the set of terminal symbols.
• p: Cardinality of the set of productions.
• g: Number of grammatical symbols in the productions.
• n: Cardinality of the set of non-terminal symbols.

4.4.1. Complexity of Algorithm 2 (Left)

The Left function checks in which productions the symbol A appears on the left side. In the first if-block, a recursive call of Left is observed, which implies that all non-terminal symbols of G could be traversed at the end of the execution in the search for $\mathtt{Left}\left(A\right)$. Therefore, all worst-case productions would be traversed, yielding a computational time of $\mathcal{O}\left(p\right)$. The second if-block has a computational time of $\mathcal{O}\left(1\right)$, which does not contribute to the overall computational time $\mathcal{O}\left(p\right)$.

4.4.2. Complexity of Algorithm 3 (Leftmost)

The Leftmost function has a similar structure to the previous one; therefore, the computational execution time is $\mathcal{O}\left(p\right)$.

4.4.3. Complexity of Algorithm 4 (Right)

The Right function has a similar structure to Left; therefore, the computational execution time is $\mathcal{O}\left(p\right)$.

4.4.4. Complexity of Algorithm 5 (Table)

According to the first for-cycle, the number of times it would be executed will be p. Immediately following the previous one, the inner for-cycle is executed in the worst-case g times, assuming that the total number of grammatical symbols appear in each production. Therefore, the computational cost of the two cycles is $\mathcal{O}(p\times g)$.

The computational costs for the construction of $\mathtt{Left}\left(A\right)$, $\mathtt{Right}\left(A\right)$, and $\mathtt{Leftmost}\left(A\right)$, $\forall A\in N$, are already computed. In computing the complexity of Table, the length of each generated set will be considered, which in the worst case is t.

The analysis of the four if-blocks inside the second for-cycle is as follows:

• In the first if-block, after checking, the executed instruction is carried out in constant time and is denoted $\mathcal{O}\left(1\right)$.
• In the second if-block, after checking, the first instruction is executed in a constant time $\mathcal{O}\left(1\right)$, and the second is executed in a computational time $\mathcal{O}\left(t\right)$; therefore, the computational time of the if-block is $\mathcal{O}\left(t\right)$.
• In the third if-block, after checking, three sub-blocks are distinguished; the first one corresponds to the travel of $\mathtt{Right}\left(A\right)$, executed in a computational time $\mathcal{O}\left(t\right)$. After checking $u\ne null$, the second sub-block presents two instructions executed in a constant time $\mathcal{O}\left(1\right)$. The third sub-block, after the checking of $l\ne \left[\right]$, presents a computational cost $\mathcal{O}(n\times t)$, determined by the for-cycle executed, in the worst case, $\mathcal{O}\left(n\right)$ times, corresponding to the number of non-terminal symbols in G and the travel it makes from $\mathtt{Right}\left(B\right)$ with a cost $\mathcal{O}\left(t\right)$. In summary, the computational cost of the third if-block is $\mathcal{O}(n\times t)$, corresponding to the worst case.
• In the fourth if-block, after checking, four sub-blocks are distinguished. The first corresponds to the combinations formed from traversing $\mathtt{Right}\left(A\right)$ and $\mathtt{Leftmost}\left(B\right)$ to obtain the precedence relations $a⋗b$. Since the maximum size of each set is t, the computational cost of these combinations is $\mathcal{O}\left(t^2\right)$. After checking $u\ne null$, the second sub-block presents an instruction where $\mathtt{Left}\left(B\right)$ is traversed; therefore, the computational cost is $\mathcal{O}\left(t\right)$. In the third sub-block, after the checking of $l\ne \left[\right]$, it presents a for-cycle that executes at most n times the combinations formed from traversing $\mathtt{Right}\left(C\right)$ and $\mathtt{Leftmost}\left(B\right)$ to obtain the precedence relations $c⋗b$. These combinations are traversed maximally in $\mathcal{O}\left(t^2\right)$ computational time because t is the size of both sets and, consequently, the computational cost of the third sub-block is $\mathcal{O}(n\times t^2)$. The last sub-block will have a cost of $\mathcal{O}\left(1\right)$. In summary, the computational cost of the fourth block is $\mathcal{O}(n\times t^2)$, corresponding to the worst case.

In summary, the computational cost of the four if-blocks within the second for-cycle of Algorithm 5 is $\mathcal{O}(n\times t^2)$, this being the worst case; therefore, the computational cost of the main body of Algorithm 5 formed by the two nested for-cycles and the four if-blocks is $\mathcal{O}(p\times g\times n\times t^2)$ which is greater than the cost of computing any of the three sets of terminal symbols $\mathtt{Left}\left(A\right)$, $\mathtt{Right}\left(A\right)$, and $\mathtt{Leftmost}\left(A\right)$, $\forall A\in N$, when starting the algorithm, and corresponding to $\mathcal{O}\left(p\right)$.

5. Examples

5.1. Example 1

5.1.1. Grammar

• Given the following OPG:
• $E⟶E+T|T$
• $T⟶T\ast F|F$
• $F⟶\left(E\right)|id$
• The sets are built step by step following the algorithms.

5.1.2. Left

The Left sets are calculated as detailed in

Table 3. Left Sets calculation for the CFG in Example 1.

Left(E)
For $E⟶E+T$
1. Evaluating the first conditional of Algorithm 2.	$A=E$	2. Evaluating the second conditional of Algorithm 2.	$A=E$
	$\beta =\epsilon$		$\beta =E$
	$B=E$		$a=+$
	$\gamma =+T$		$\gamma =T$
	$\mathcal{L}\left(E\right)\supseteq \mathcal{L}\left(E\right)$		$\mathcal{L}\left(E\right)\supseteq \{+\}$
For $E⟶T$
3. Evaluating the first conditional of Algorithm 2.	$A=E$
	$\beta =\epsilon$
	$B=T$
	$\gamma =\epsilon$
	$\mathcal{L}\left(E\right)=\{+\}\cup \mathcal{L}\left(T\right)$
Left(T)
For $T⟶T\ast F$
1. Evaluating the first conditional of Algorithm 2.	$A=T$	2. Evaluating the second conditional of Algorithm 2.	$A=T$
	$\beta =\epsilon$		$\beta =T$
	$B=T$		$a=\ast$
	$\gamma =\ast F$		$\gamma =F$
	$\mathcal{L}\left(T\right)\supseteq \mathcal{L}\left(T\right)$		$\mathcal{L}\left(T\right)\supseteq \{\ast \}$
For $T⟶F$
3. Evaluating the first conditional of Algorithm 2.	$A=T$
	$\beta =\epsilon$
	$B=F$
	$\gamma =\epsilon$
	$\mathcal{L}\left(T\right)=\{\ast \}\cup \mathcal{L}\left(F\right)$
Left(F)
For $F⟶\left(E\right)$		For $F⟶id$
1. Evaluating the second conditional of Algorithm 2.	$A=F$	2. Evaluating the second conditional of Algorithm 2.	$A=F$
	$\beta =\epsilon$		$\beta =\epsilon$
	$a=($		$a=id$
	$\gamma =E)$		$\gamma =\epsilon$
	$\mathcal{L}\left(F\right)\supseteq \left\{\right(\}$		$\mathcal{L}\left(F\right)=\left\{\right(,id\}$

.

• Summary of $\mathtt{Left}$ sets of non-terminals:

• $\mathtt{Left}\left(E\right)=\{+\}\cup \mathcal{L}\left(T\right).$
• $\mathtt{Left}\left(T\right)=\{\ast \}\cup \mathcal{L}\left(F\right).$
• $\mathtt{Left}\left(F\right)=\left\{\right(,id\}.$

• Substituting the sets:

• $\mathtt{Left}\left(E\right)=\{+,\ast ,(,id\}.$
• $\mathtt{Left}\left(T\right)=\{\ast ,(,id\}.$
• $\mathtt{Left}\left(F\right)=\left\{\right(,id\}.$

5.1.3. Right

The Right sets are calculated as detailed in

Table 4. Right Sets calculation for the CFG in Example 1.

Right(E)
For $E⟶E+T$
1. Evaluating the first conditional of Algorithm 4.	$A=E$	2. Evaluating the second conditional of Algorithm 4.	$A=E$
	$\gamma =E+$		$\gamma =E$
	$B=T$		$a=+$
	$\beta =\epsilon$		$\beta =T$
	$\mathcal{R}\left(E\right)\supseteq \mathcal{R}\left(T\right)$		$\mathcal{R}\left(E\right)\supseteq \mathcal{R}\left(T\right)\cup \{+\}$
For $E⟶T$
3. Evaluating the first conditional of Algorithm 4.	$A=E$
	$\gamma =\epsilon$
	$B=T$
	$\beta =\epsilon$
	$\mathcal{R}\left(E\right)=\mathcal{R}\left(T\right)\cup \{+\}$
Right(T)
For $T⟶T\ast F$
1. Evaluating the first conditional of Algorithm 4.	$A=T$	2. Evaluating the second conditional of Algorithm 4.	$A=T$
	$\gamma =T\ast$		$\gamma =T$
	$B=F$		$a=\ast$
	$\beta =\epsilon$		$\beta =F$
	$\mathcal{R}\left(T\right)\supseteq \mathcal{R}\left(F\right)$		$\mathcal{R}\left(T\right)\supseteq \mathcal{R}\left(F\right)\cup \{\ast \}$
For $T⟶F$
3. Evaluating the first conditional of Algorithm 4.	$A=T$
	$\gamma =\epsilon$
	$B=F$
	$\beta =\epsilon$
	$\mathcal{R}\left(T\right)=\mathcal{R}\left(F\right)\cup \{\ast \}$
Right(F)
For $F⟶\left(E\right)$		For $F⟶id$
1. Evaluating the second conditional of Algorithm 2.	$A=F$	2. Evaluating the second conditional of Algorithm 2.	$A=F$
	$\gamma =(E$		$\gamma =\epsilon$
	$a=)$		$a=id$
	$\beta =\epsilon$		$\beta =\epsilon$
	$\mathcal{R}\left(F\right)\supseteq \left\{\right)\}$		$\mathcal{R}\left(F\right)=\left\{\right),id\}$

.

• Summary of $\mathtt{Right}$ sets of non-terminals:

• $\mathtt{Right}\left(E\right)=\mathcal{R}\left(T\right)\cup \{+\}.$
• $\mathtt{Right}\left(T\right)=\mathcal{R}\left(F\right)\cup \{\ast \}.$
• $\mathtt{Right}\left(F\right)=\left\{\right),id\}.$

• Substituting the sets:

• $\mathtt{Right}\left(E\right)=\left\{\right),id,\ast ,+\}.$
• $\mathtt{Right}\left(T\right)=\left\{\right),id,\ast \}.$
• $\mathtt{Right}\left(F\right)=\left\{\right),id\}.$

5.1.4. Leftmost

The Leftmost are calculated as detailed in

Table 5. Leftmost Sets calculation for the CFG in Example 1.

Leftmost(E)
For $E⟶E+T$		For $E⟶T$
1. Evaluating the first conditional of Algorithm 3.	$A=E$	2. Evaluating the first conditional of Algorithm 3.	$A=E$
	$\beta =\epsilon$		$\beta =\epsilon$
	$B=E$		$B=T$
	$\gamma =+T$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(E\right)\supseteq {\mathcal{L}}_m\left(E\right)$		${\mathcal{L}}_m\left(E\right)={\mathcal{L}}_m\left(T\right)$
Leftmost(T)
For $T⟶T\ast F$		For $T⟶F$
1. Evaluating the first conditional of Algorithm 3.	$A=T$	2. Evaluating the first conditional of Algorithm 3.	$A=T$
	$\beta =\epsilon$		$\beta =\epsilon$
	$B=T$		$B=F$
	$\gamma =\ast F$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(T\right)\supseteq {\mathcal{L}}_m\left(T\right)$		${\mathcal{L}}_m\left(T\right)={\mathcal{L}}_m\left(F\right)$
Leftmost(F)
For $F⟶\left(E\right)$		For $F⟶id$
1. Evaluating the second conditional of Algorithm 3.	$A=F$	2. Evaluating the second conditional of Algorithm 3.	$A=F$
	$\beta =\epsilon$		$\beta =\epsilon$
	$a=($		$a=id$
	$\gamma =E)$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(F\right)\supseteq \{\left(\right\}$		${\mathcal{L}}_m\left(F\right)=\{(,id\}$

.

• Summary of $\mathtt{Leftmost}$ sets of non-terminals:

• $\mathtt{Leftmost}\left(E\right)={\mathcal{L}}_m\left(T\right).$
• $\mathtt{Leftmost}\left(T\right)={\mathcal{L}}_m\left(F\right).$
• $\mathtt{Leftmost}\left(F\right)=\left\{\right(,id\}.$

• Substituting the sets:

• $\mathtt{Leftmost}\left(E\right)=\left\{\right(,id\}.$
• $\mathtt{Leftmost}\left(T\right)=\left\{\right(,id\}.$
• $\mathtt{Leftmost}\left(F\right)=\left\{\right(,id\}.$

5.1.5. Case Studies

For Algorithm 5, the application of some precedence relations is exhibited.

• For the delimiter symbol $:

  (a)

  $\$⋖\mathcal{L}\left(E\right)\to$ Rule (A.1).

  • $\$⋖+$
  • $\$⋖\ast$
  • $\$⋖($
  • $\$⋖id$

  (b)

  $\mathcal{R}\left(E\right)⋗\$\to$ Rule (A.2).

  • $)⋗\$$
  • $id⋗\$$
  • $\ast ⋗\$$
  • $+⋗\$$

• For $E⟶E+T$

  (a)

  $X=E,Y=+\to$ Rule (D.1).

  $\mathcal{R}\left(E\right)⋗+$

  • $)⋗+$
  • $id⋗+$
  • $\ast ⋗+$
  • $+⋗+$

  $u=null,l=\left[\right]$

  (b)

  $X=+,Y=T\to$ Rule (C).

  $+⋖\mathcal{L}\left(T\right)$

  • $+⋖\ast$
  • $+⋖($
  • $+⋖id$

  $u=+,l=\left[\right]$

• For $F⟶\left(E\right)$

  (a)

  $X=(,Y=E\to$ Rule (C).

  $(⋖\mathcal{L}(E)$

  • $(⋖+$
  • $(⋖\ast$
  • $(⋖($
  • $(⋖id$

  $u=(,l=[]$

  (b)

  $X=E,Y=)\to$ Rule (D.1).

  $\mathcal{R}\left(E\right)⋗)$

  • $)⋗)$
  • $id⋗)$
  • $\ast ⋗)$
  • $+⋗)$

  $u\ne null\to u\doteq b\to (\doteq )\to$ Rule (D.2).

  $u=null,l=\left[\right]$

• In the following cases, the form $XY$ is not fulfilled in the right side part of the production; therefore, no rule can be applied:

  (a)

  $E⟶T$

  (b)

  $T⟶F$

  (c)

  $F⟶id$

The remaining precedence relations are derived using the same method as the previously demonstrated cases.

5.1.6. Operator Precedence Table

At the end of the algorithm execution, operator precedence

Table 6. Precedence Table of Example 1.

	+	∗	(	)	$id$	$
+	⋗	⋖	⋖	⋗	⋖	⋗
∗	⋗	⋗	⋖	⋗	⋖	⋗
(	⋖	⋖	⋖	≐	⋖
)	⋗	⋗		⋗		⋗
$id$	⋗	⋗		⋗		⋗
$	⋖	⋖	⋖		⋖

is obtained.

5.1.7. Bottom-Up Parsing

Let $id+\left(\right(id+id)\ast (id\left)\right)\ast id$ be a string obtained by rightmost derivation, then applying Algorithm 1 results in the bottom-up parsing detailed in

Table 7. Bottom-up Parsing of Example 1.

Stack	Input	Action
$	$id+\left(\right(id+id)\ast (id\left)\right)\ast id\$$	Shift
$\$id$	$+\left(\right(id+id)\ast (id\left)\right)\ast id\$$	Reduce
$	$+\left(\right(id+id)\ast (id\left)\right)\ast id\$$	Shift
$\$+$	$\left(\right(id+id)\ast (id\left)\right)\ast id\$$	Shift
$\$+($	$(id+id)\ast \left(id\right))\ast id\$$	Shift
$\$+\left(\right($	$id+id)\ast (id\left)\right)\ast id\$$	Shift
$\$+\left(\right(id$	$+id)\ast (id\left)\right)\ast id\$$	Reduce
$\$+\left(\right($	$+id)\ast (id\left)\right)\ast id\$$	Shift
$\$+\left(\right(+$	$id)\ast (id\left)\right)\ast id\$$	Shift
$\$+\left(\right(+id$	$)\ast (id\left)\right)\ast id\$$	Reduce
$\$+\left(\right(+$	$)\ast (id\left)\right)\ast id\$$	Reduce
$\$+\left(\right($	$)\ast (id\left)\right)\ast id\$$	Shift
$\$+\left(\right()$	$\ast \left(id\right))\ast id\$$	Reduce
$\$+($	$\ast \left(id\right))\ast id\$$	Shift
$\$+(\ast$	$\left(id\right))\ast id\$$	Shift
$\$+(\ast ($	$id\left)\right)\ast id\$$	Shift
$\$+(\ast (id$	$\left)\right)\ast id\$$	Reduce
$\$+(\ast ($	$\left)\right)\ast id\$$	Shift
$\$+(\ast ()$	$)\ast id\$$	Reduce
$\$+(\ast$	$)\ast id\$$	Reduce
$\$+($	$)\ast id\$$	Shift
$\$+\left(\right)$	$\ast id\$$	Reduce
$\$+$	$\ast id\$$	Shift
$\$+\ast$	$id\$$	Shift
$\$+\ast id$	$	Reduce
$\$+\ast$	$	Reduce
$\$+$	$	Reduce
$	$	Accept

.

5.2. Example 2

5.2.1. Grammar

• Given the following non-OPG:
• $S⟶SD;|D;$
• $D⟶Tid\left(L\right)$
• $T⟶T\ast |int$
• $L⟶I|\epsilon$
• $I⟶T|T,I$
• The sets are built step by step following the algorithms.

5.2.2. Left

The Left sets are calculated as detailed in

Table 8. Left Sets calculation for the CFG in Example 2.

Left(S)
For $S⟶SD;$
1. Evaluating the first conditional of Algorithm 2.	$A=S$	2. Evaluating the first conditional of Algorithm 2.	$A=S$
	$\beta =\epsilon$		$\beta =S$
	$B=S$		$B=D$
	$\gamma =D;$		$\gamma =;$
	$\mathcal{L}\left(S\right)\supseteq \mathcal{L}\left(S\right)$		$\mathcal{L}\left(S\right)\supseteq \mathcal{L}\left(D\right)$
3. Evaluating the second conditional of Algorithm 2.	$A=S$
	$\beta =SD$
	$a=;$
	$\gamma =\epsilon$
	$\mathcal{L}\left(S\right)\supseteq \mathcal{L}\left(D\right)\cup \{;\}$
For $S⟶D;$
4. Evaluating the first conditional of Algorithm 2.	$A=S$	5. Evaluating the second conditional of Algorithm 2.	$A=S$
	$\beta =\epsilon$		$\beta =D$
	$B=D$		$a=;$
	$\gamma =;$		$\gamma =\epsilon$
	$\mathcal{L}\left(S\right)\supseteq \mathcal{L}\left(D\right)\cup \{;\}\cup \mathcal{L}\left(D\right)$		$\mathcal{L}\left(S\right)=\mathcal{L}\left(D\right)\cup \{;\}$
Left(D)
For $D⟶Tid\left(L\right)$
1. Evaluating the first conditional of Algorithm 2.	$A=D$	2. Evaluating the second conditional of Algorithm 2.	$A=D$
	$\beta =\epsilon$		$\beta =T$
	$B=T$		$a=id$
	$\gamma =id\left(L\right)$		$\gamma =\left(L\right)$
	$\mathcal{L}\left(D\right)\supseteq \mathcal{L}\left(T\right)$		$\mathcal{L}\left(D\right)=\mathcal{L}\left(T\right)\cup \left\{id\right\}$
Left(T)
For $T⟶T\ast$
1. Evaluating the first conditional of Algorithm 2.	$A=T$	2. Evaluating the second conditional of Algorithm 2.	$A=T$
	$\beta =\epsilon$		$\beta =T$
	$B=T$		$a=\ast$
	$\gamma =\ast$		$\gamma =\epsilon$
	$\mathcal{L}\left(T\right)\supseteq \mathcal{L}\left(T\right)$		$\mathcal{L}\left(T\right)\supseteq \{\ast \}$
For $T⟶int$
3. Evaluating the second conditional of Algorithm 2.	$A=T$
	$\beta =\epsilon$
	$a=int$
	$\gamma =\epsilon$
	$\mathcal{L}\left(T\right)=\{\ast ,int\}$
Left(L)
For $L⟶I$
1. Evaluating the first conditional of Algorithm 2.	$A=L$
	$\beta =\epsilon$
	$B=I$
	$\gamma =\epsilon$
$\mathcal{L}\left(L\right)=\mathcal{L}\left(I\right)$
Left(I)
For $I⟶T$
1. Evaluating the first conditional of Algorithm 2.	$A=I$
	$\beta =\epsilon$
	$B=T$
	$\gamma =\epsilon$
	$\mathcal{L}\left(I\right)\supseteq \mathcal{L}\left(T\right)$
For $I⟶T,I$
2. Evaluating the first conditional of Algorithm 2.	$A=I$	3. Evaluating the second conditional of Algorithm 2.	$A=I$
	$\beta =\epsilon$		$\beta =T$
	$B=T$		$a=,$
	$\gamma =,I$		$\gamma =I$
	$\mathcal{L}\left(I\right)\supseteq \mathcal{L}\left(T\right)$		$\mathcal{L}\left(I\right)=\mathcal{L}\left(T\right)\cup \{,\}$

.

• Summary of $\mathtt{Left}$ sets of non-terminals:

• $\mathtt{Left}\left(S\right)=\mathcal{L}\left(D\right)\cup \{;\}.$
• $\mathtt{Left}\left(D\right)=\mathcal{L}\left(T\right)\cup \left\{id\right\}.$
• $\mathtt{Left}\left(T\right)=\{\ast ,int\}.$
• $\mathtt{Left}\left(L\right)=\mathcal{L}\left(I\right).$
• $\mathtt{Left}\left(I\right)=\mathcal{L}\left(T\right)\cup \{,\}.$

• Substituting the sets:

• $\mathtt{Left}\left(S\right)=\{;,id,\ast ,int\}.$
• $\mathtt{Left}\left(D\right)=\{id,\ast ,int\}.$
• $\mathtt{Left}\left(T\right)=\{\ast ,int\}.$
• $\mathtt{Left}\left(L\right)=\{,,\ast ,int\}.$
• $\mathtt{Left}\left(I\right)=\{,,\ast ,int\}.$

5.2.3. Right

The Right sets are calculated as detailed in

Table 9. Right Sets calculation for the CFG in Example 2.

Right(S)
For $S⟶SD;$		For $S⟶D;$
1. Evaluating the second conditional of Algorithm 4.	$A=S$	2. Evaluating the second conditional of Algorithm 4.	$A=S$
	$\gamma =SD$		$\gamma =D$
	$a=;$		$a=;$
	$\beta =\epsilon$		$\beta =\epsilon$
	$\mathcal{R}\left(S\right)\supseteq \{;\}$		$\mathcal{R}\left(S\right)=\{;\}$
Right(D)
For $D⟶Tid\left(L\right)$
1. Evaluating the second conditional of Algorithm 4.	$A=D$
	$\gamma =Tid(L$
	$a=)$
	$\beta =\epsilon$
	$\mathcal{R}\left(D\right)=\left\{\right)\}$
Right(T)
For $T⟶T\ast$		For $T⟶int$
1. Evaluating the second conditional of Algorithm 4.	$A=T$	2. Evaluating the second conditional of Algorithm 4.	$A=T$
	$\gamma =T$		$\gamma =\epsilon$
	$a=\ast$		$a=int$
	$\beta =\epsilon$		$\beta =\epsilon$
	$\mathcal{R}\left(T\right)\supseteq \{\ast \}$		$\mathcal{R}\left(T\right)=\{\ast ,int\}$
Right(L)
For $L⟶I$
1. Evaluating the first conditional of Algorithm 4.	$A=L$
	$\gamma =\epsilon$
	$B=I$
	$\beta =\epsilon$
	$\mathcal{R}\left(L\right)=\mathcal{R}\left(I\right)$
Right(I)
For $I⟶T$
1. Evaluating the first conditional of Algorithm 4.	$A=I$
	$\gamma =\epsilon$
	$B=T$
	$\beta =\epsilon$
	$\mathcal{R}\left(I\right)\supseteq \mathcal{R}\left(T\right)$
For $I⟶T,I$
2. Evaluating the first conditional of Algorithm 4.	$A=I$	3. Evaluating the second conditional of Algorithm 4.	$A=I$
	$\gamma =T,$		$\gamma =T$
	$B=I$		$a=,$
	$\beta =\epsilon$		$\beta =I$
	$\mathcal{R}\left(I\right)\supseteq \mathcal{R}\left(T\right)\cup \mathcal{R}\left(I\right)$		$\mathcal{R}\left(I\right)=\mathcal{R}\left(T\right)\cup \{,\}$

.

• Summary of $\mathtt{Right}$ sets of non-terminals:

• $\mathtt{Right}\left(S\right)=\{;\}.$
• $\mathtt{Right}\left(D\right)=\left\{\right)\}.$
• $\mathtt{Right}\left(T\right)=\{\ast ,int\}.$
• $\mathtt{Right}\left(L\right)=\mathcal{R}\left(I\right).$
• $\mathtt{Right}\left(I\right)=\mathcal{R}\left(T\right)\cup \{,\}.$

• Substituting the sets:

• $\mathtt{Right}\left(S\right)=\{;\}.$
• $\mathtt{Right}\left(D\right)=\left\{\right)\}.$
• $\mathtt{Right}\left(T\right)=\{\ast ,int\}.$
• $\mathtt{Right}\left(L\right)=\{,,\ast ,int\}.$
• $\mathtt{Right}\left(I\right)=\{,,\ast ,int\}.$

5.2.4. Leftmost

The Leftmost sets are calculated as detailed in

Table 10. Leftmost Sets calculation for the CFG in Example 2.

Leftmost(S)
For $S⟶SD;$		For $S⟶D;$
1. Evaluating the first conditional of Algorithm 3.	$A=S$	2. Evaluating the first conditional of Algorithm 3.	$A=S$
	$\beta =\epsilon$		$\beta =\epsilon$
	$B=S$		$B=D$
	$\gamma =D;$		$\gamma =;$
	${\mathcal{L}}_m\left(S\right)\supseteq {\mathcal{L}}_m\left(S\right)$		${\mathcal{L}}_m\left(S\right)={\mathcal{L}}_m\left(D\right)$
Leftmost(D)
For $D⟶Tid\left(L\right)$
1. Evaluating the first conditional of Algorithm 3.	$A=D$
	$\beta =\epsilon$
	$B=T$
	$\gamma =id\left(L\right)$
	${\mathcal{L}}_m\left(D\right)={\mathcal{L}}_m\left(T\right)$
Leftmost(T)
For $T⟶T\ast$		For $T⟶int$
1. Evaluating the first conditional of Algorithm 3.	$A=T$	2. Evaluating the second conditional of Algorithm 3.	$A=T$
	$\beta =\epsilon$		$\beta =\epsilon$
	$B=T$		$a=int$
	$\gamma =\ast$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(T\right)\supseteq {\mathcal{L}}_m\left(T\right)$		${\mathcal{L}}_m\left(T\right)=\left\{int\right\}$
Leftmost(L)
For $L⟶I$
1. Evaluating the first conditional of Algorithm 3.	$A=L$
	$\beta =\epsilon$
	$B=I$
	$\gamma =\epsilon$
	${\mathcal{L}}_m\left(L\right)={\mathcal{L}}_m\left(I\right)$
Leftmost(I)
For $I⟶T$		For $I⟶T,I$
1. Evaluating the first conditional of Algorithm 3.	$A=I$	2. Evaluating the first conditional of Algorithm 3.	$A=I$
	$\beta =\epsilon$		$\beta =\epsilon$
	$B=T$		$B=T$
	$\gamma =\epsilon$		$\gamma =,I$
	${\mathcal{L}}_m\left(I\right)\supseteq {\mathcal{L}}_m\left(T\right)$		${\mathcal{L}}_m\left(I\right)={\mathcal{L}}_m\left(T\right)$

.

• Summary of $\mathtt{Leftmost}$ sets of non-terminals:

• $\mathtt{Leftmost}\left(S\right)={\mathcal{L}}_m\left(D\right).$
• $\mathtt{Leftmost}\left(D\right)={\mathcal{L}}_m\left(T\right).$
• $\mathtt{Leftmost}\left(T\right)=\left\{int\right\}.$
• $\mathtt{Leftmost}\left(L\right)={\mathcal{L}}_m\left(I\right).$
• $\mathtt{Leftmost}\left(I\right)={\mathcal{L}}_m\left(T\right).$

• Substituting the sets:

• $\mathtt{Leftmost}\left(S\right)=\left\{int\right\}.$
• $\mathtt{Leftmost}\left(D\right)=\left\{int\right\}.$
• $\mathtt{Leftmost}\left(T\right)=\left\{int\right\}.$
• $\mathtt{Leftmost}\left(L\right)=\left\{int\right\}.$
• $\mathtt{Leftmost}\left(I\right)=\left\{int\right\}.$

5.2.5. Case Studies

For Algorithm 5, the application of some precedence relations is exhibited.

• For the delimiter symbol $:

  (a)

  $\$⋖\mathcal{L}\left(S\right)\to$ Rule (A.1).

  • $\$⋖;$
  • $\$⋖id$
  • $\$⋖\ast$
  • $\$⋖int$

  (b)

  $\mathcal{R}\left(S\right)⋗\$\to$ Rule (A.2).

  • $;⋗\$$

• For $S⟶SD;$

  (a)

  $X=S,Y=D\to$ Rule (E.1).

  $\mathcal{R}\left(S\right)⋗{\mathcal{L}}_m\left(D\right)$

  • $;⋗int$

  $u=null,l=\left[\right]$

  (b)

  $X=D,Y=;\to$ Rule (D.1).

  $\mathcal{R}\left(D\right)⋗;$

  • $)⋗;$

  $u=null,l=\left[\right]$

• For $D⟶Tid\left(L\right)$

  (a)

  $X=id,Y=(\to$ Rule (B).

  • $id\doteq ($

  $u=null,l=\left[\right]$

  (b)

  $X=(,Y=L\to$ Rule (C).

  $(⋖\mathcal{L}(L)$

  • $(⋖,$
  • $(⋖\ast$
  • $(⋖int$

  $u=(,l=[]$

  (c)

  $X=L,Y=)\to$ Rule (D.1).

  $\mathcal{R}\left(L\right)⋗)$

  • $,⋗)$
  • $\ast ⋗)$
  • $int⋗)$

  $u\ne null\to u\doteq b\to (\doteq )\to$ Rule (D.2).

  $u=null,l=\left[\right]$

• In the following cases, the form $XY$ is not fulfilled in the right side part of the production; therefore, no rule can be applied:

  (a)

  $T⟶int$

  (b)

  $L⟶I$

  (c)

  $L⟶\epsilon$

  (d)

  $I⟶T$

The remaining precedence relations are derived using the same method as the previously demonstrated cases.

5.2.6. Operator Precedence Table

At the end of the algorithm execution, operator precedence

Table 11. Precedence Table of Example 2.

	;	$id$	(	)	∗	$int$	,	$
;						⋗		⋗
$id$			≐
(				≐	⋖	⋖	⋖
)	⋗
∗		⋗		⋗	⋗		⋗
$int$		⋗		⋗	⋗		⋗
,				⋗	⋖	⋖	⋖
$	⋖	⋖			⋖	⋖

is obtained.

5.2.7. Bottom-Up Parsing

Let $intid\left(\right);intid(int,int);$ be a string obtained by rightmost derivation, then applying Algorithm 1 results in the bottom-up parsing detailed in

Table 12. Bottom-up Parsing of Example 2.

Stack	Input	Action
$	$intid\left(\right);intid(int,int);\$$	Shift
$\$int$	$id\left(\right);intid(int,int);\$$	Reduce
$	$id\left(\right);intid(int,int);\$$	Shift
$\$id$	$\left(\right);intid(int,int);\$$	Shift
$\$id($	$);intid(int,int);\$$	Shift
$\$id\left(\right)$	$;intid(int,int);\$$	Reduce
$	$;intid(int,int);\$$	Shift
$\$;$	$intid(int,int);\$$	Reduce
$	$intid(int,int);\$$	Shift
$\$int$	$id(int,int);\$$	Reduce
$	$id(int,int);\$$	Shift
$\$id$	$(int,int);\$$	Shift
$\$id($	$int,int);\$$	Shift
$\$id(int$	$,int);\$$	Reduce
$\$id($	$,int);\$$	Shift
$\$id(,$	$int);\$$	Shift
$\$id(,int$	$);\$$	Reduce
$\$id(,$	$);\$$	Reduce
$\$id($	$);\$$	Shift
$\$id\left(\right)$	$;\$$	Reduce
$	$;\$$	Shift
$\$;$	$	Reduce
$	$	Accept

.

5.3. Example 3

5.3.1. Grammar

• Given the following non-OPG:
  $S⟶ABC$
• $A⟶aA|a$
• $B⟶bB\left|b\right|\epsilon$
• $C⟶CDc|c$
• $D⟶d$
• The sets are built step by step following the algorithms.

5.3.2. Left

The Left sets are calculated as detailed in

Table 13. Left Sets calculation for the CFG in Example 3.

Left(S)
For $S⟶ABC$
1. Evaluating the first conditional of Algorithm 2.	$A=S$	2. Evaluating the first conditional of Algorithm 2.	$A=S$
	$\beta =\epsilon$		$\beta =A$
	$B=A$		$B=B$
	$\gamma =BC$		$\gamma =C$
	$\mathcal{L}\left(S\right)\supseteq \mathcal{L}\left(A\right)$		$\mathcal{L}\left(S\right)\supseteq \mathcal{L}\left(A\right)\cup \mathcal{L}\left(B\right)$
3. Evaluating the first conditional of Algorithm 2.	$A=S$
	$\beta =AB$
	$B=C$
	$\gamma =\epsilon$
	$\mathcal{L}\left(S\right)=\mathcal{L}\left(A\right)\cup \mathcal{L}\left(B\right)\cup \mathcal{L}\left(C\right)$
Left(A)
For $A⟶aA$
1. Evaluating the second conditional of Algorithm 2.	$A=A$	2. Evaluating the first conditional of Algorithm 2.	$A=A$
	$\beta =\epsilon$		$\beta =a$
	$a=a$		$B=A$
	$\gamma =A$		$\gamma =\epsilon$
	$\mathcal{L}\left(A\right)\supseteq \left\{a\right\}$		$\mathcal{L}\left(A\right)\supseteq \left\{a\right\}\cup \mathcal{L}\left(A\right)$
For $A⟶a$
3. Evaluating the second conditional of Algorithm 2.	$A=A$
	$\beta =\epsilon$
	$a=a$
	$\gamma =\epsilon$
	$\mathcal{L}\left(A\right)=\left\{a\right\}$
Left(B)
For $B⟶bB$
1. Evaluating the second conditional of Algorithm 2.	$A=B$	2. Evaluating the first conditional of Algorithm 2.	$A=B$
	$\beta =\epsilon$		$\beta =b$
	$a=b$		$B=B$
	$\gamma =B$		$\gamma =\epsilon$
	$\mathcal{L}\left(B\right)\supseteq \left\{b\right\}$		$\mathcal{L}\left(B\right)\supseteq \left\{b\right\}\cup \mathcal{L}\left(B\right)$
For $B⟶b$
3. Evaluating the second conditional of Algorithm 2.	$A=B$
	$\beta =\epsilon$
	$a=b$
	$\gamma =\epsilon$
	$\mathcal{L}\left(B\right)=\left\{b\right\}$
Left(C)
For $C⟶CDc$
1. Evaluating the first conditional of Algorithm 2.	$A=C$	2. Evaluating the first conditional of Algorithm 2.	$A=C$
	$\beta =\epsilon$		$\beta =C$
	$B=C$		$B=D$
	$\gamma =Dc$		$\gamma =c$
	$\mathcal{L}\left(C\right)\supseteq \mathcal{L}\left(C\right)$		$\mathcal{L}\left(C\right)\supseteq \mathcal{L}\left(D\right)$
3. Evaluating the second conditional of Algorithm 2.	$A=C$
	$\beta =CD$
	$a=c$
	$\gamma =\epsilon$
	$\mathcal{L}\left(C\right)\supseteq \mathcal{L}\left(D\right)\cup \left\{c\right\}$
For $C⟶c$
4. Evaluating the second conditional of Algorithm 2.	$A=C$
	$\beta =\epsilon$
	$a=c$
	$\gamma =\epsilon$
	$\mathcal{L}\left(C\right)=\mathcal{L}\left(D\right)\cup \left\{c\right\}$
Left(D)
For $D⟶d$
1. Evaluating the second conditional of Algorithm 2.	$A=D$
	$\beta =\epsilon$
	$a=d$
	$\gamma =\epsilon$
	$\mathcal{L}\left(D\right)=\left\{d\right\}$

.

• Summary of $\mathtt{Left}$ sets of non-terminals:

• $\mathtt{Left}\left(S\right)=\mathcal{L}\left(A\right)\cup \mathcal{L}\left(B\right)\cup \mathcal{L}\left(C\right).$
• $\mathtt{Left}\left(A\right)=\left\{a\right\}.$
• $\mathtt{Left}\left(B\right)=\left\{b\right\}.$
• $\mathtt{Left}\left(C\right)=\mathcal{L}\left(D\right)\cup \left\{c\right\}.$
• $\mathtt{Left}\left(D\right)=\left\{d\right\}.$

• Substituting the sets:

• $\mathtt{Left}\left(S\right)=\{a,b,d,c\}.$
• $\mathtt{Left}\left(A\right)=\left\{a\right\}.$
• $\mathtt{Left}\left(B\right)=\left\{b\right\}.$
• $\mathtt{Left}\left(C\right)=\{d,c\}.$
• $\mathtt{Left}\left(D\right)=\left\{d\right\}.$

5.3.3. Right

The Right sets are calculated as detailed in

Table 14. Right Sets calculation for the CFG in Example 3.

Right(S)
For $S⟶ABC$
1. Evaluating the first conditional of Algorithm 4.	$A=S$
	$\gamma =AB$
	$B=C$
	$\beta =\epsilon$
	$\mathcal{R}\left(S\right)=\mathcal{R}\left(C\right)$
Right(A)
For $A⟶aA$
1. Evaluating the first conditional of Algorithm 4.	$A=A$	2. Evaluating the second conditional of Algorithm 4.	$A=A$
	$\gamma =a$		$\gamma =\epsilon$
	$B=A$		$a=a$
	$\beta =\epsilon$		$\beta =A$
	$\mathcal{R}\left(A\right)\supseteq \mathcal{R}\left(A\right)$		$\mathcal{R}\left(A\right)\supseteq \left\{a\right\}$
For $A⟶a$
3. Evaluating the second conditional of Algorithm 4.	$A=A$
	$\gamma =\epsilon$
	$a=a$
	$\beta =\epsilon$
	$\mathcal{R}\left(A\right)=\left\{a\right\}$
Right(B)
For $B⟶bB$
1. Evaluating the first conditional of Algorithm 4.	$A=B$	2. Evaluating the second conditional of Algorithm 4.	$A=B$
	$\gamma =b$		$\gamma =\epsilon$
	$B=B$		$a=b$
	$\beta =\epsilon$		$\beta =B$
	$\mathcal{R}\left(B\right)\supseteq \mathcal{R}\left(B\right)$		$\mathcal{R}\left(B\right)\supseteq \left\{b\right\}$
For $B⟶b$
3. Evaluating the second conditional of Algorithm 4.	$A=B$
	$\gamma =\epsilon$
	$a=b$
	$\beta =\epsilon$
	$\mathcal{R}\left(b\right)=\left\{b\right\}$
Right(C)
For $C⟶CDc$		For $C⟶c$
1. Evaluating the second conditional of Algorithm 4.	$A=C$	2. Evaluating the second conditional of Algorithm 4.	$A=C$
	$\gamma =CD$		$\gamma =\epsilon$
	$a=c$		$a=c$
	$\beta =\epsilon$		$\beta =\epsilon$
	$\mathcal{R}\left(C\right)\supseteq \left\{c\right\}$		$\mathcal{R}\left(C\right)=\left\{c\right\}$
Right(D)
For $D⟶d$
1. Evaluating the second conditional of Algorithm 4.	$A=D$
	$\gamma =\epsilon$
	$a=d$
	$\beta =\epsilon$
	$\mathcal{R}\left(D\right)=\left\{d\right\}$

• Summary of $\mathtt{Right}$ sets of non-terminals:

• $\mathtt{Right}\left(S\right)=\mathcal{R}\left(C\right).$
• $\mathtt{Right}\left(A\right)=\left\{a\right\}.$
• $\mathtt{Right}\left(B\right)=\left\{b\right\}.$
• $\mathtt{Right}\left(C\right)=\left\{c\right\}.$
• $\mathtt{Right}\left(D\right)=\left\{d\right\}.$

• Substituting the sets:

• $\mathtt{Right}\left(S\right)=\left\{c\right\}.$
• $\mathtt{Right}\left(A\right)=\left\{a\right\}.$
• $\mathtt{Right}\left(B\right)=\left\{b\right\}.$
• $\mathtt{Right}\left(C\right)=\left\{c\right\}.$
• $\mathtt{Right}\left(D\right)=\left\{d\right\}.$

5.3.4. Leftmost

The Leftmost sets are calculated as detailed in

Table 15. Leftmost Sets calculation for the CFG in Example 3.

Leftmost(S)
For $S⟶ABC$
1. Evaluating the first conditional of Algorithm 3.	$A=S$
	$\beta =\epsilon$
	$B=A$
	$\gamma =BC$
	${\mathcal{L}}_m\left(S\right)={\mathcal{L}}_m\left(A\right)$
Leftmost(A)
For $A⟶aA$		For $A⟶a$
1. Evaluating the second conditional of Algorithm 3.	$A=A$	2. Evaluating the second conditional of Algorithm 3.	$A=A$
	$\beta =\epsilon$		$\beta =\epsilon$
	$a=a$		$a=a$
	$\gamma =A$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(A\right)\supseteq \left\{a\right\}$		${\mathcal{L}}_m\left(A\right)=\left\{a\right\}$
Leftmost(B)
For $B⟶bB$		For $B⟶b$
1. Evaluating the second conditional of Algorithm 3.	$A=B$	2. Evaluating the second conditional of Algorithm 3.	$A=B$
	$\beta =\epsilon$		$\beta =\epsilon$
	$a=b$		$a=b$
	$\gamma =B$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(B\right)\supseteq \left\{b\right\}$		${\mathcal{L}}_m\left(B\right)=\left\{b\right\}$
Leftmost(C)
For $C⟶CDc$		For $C⟶c$
1. Evaluating the first conditional of Algorithm 3.	$A=C$	2. Evaluating the second conditional of Algorithm 3.	$A=C$
	$\beta =\epsilon$		$\beta =\epsilon$
	$B=C$		$a=c$
	$\gamma =Dc$		$\gamma =\epsilon$
	${\mathcal{L}}_m\left(C\right)\supseteq {\mathcal{L}}_m\left(C\right)$		${\mathcal{L}}_m\left(C\right)=\left\{c\right\}$
Leftmost(D)
For $D⟶d$
1. Evaluating the second conditional of Algorithm 3.	$A=D$
	$\beta =\epsilon$
	$a=d$
	$\gamma =\epsilon$
	${\mathcal{L}}_m\left(D\right)=\left\{d\right\}$

.

• Summary of $\mathtt{Leftmost}$ sets of non-terminals:

• $\mathtt{Leftmost}\left(S\right)={\mathcal{L}}_m\left(A\right).$
• $\mathtt{Leftmost}\left(A\right)=\left\{a\right\}.$
• $\mathtt{Leftmost}\left(B\right)=\left\{b\right\}.$
• $\mathtt{Leftmost}\left(C\right)=\left\{c\right\}.$
• $\mathtt{Leftmost}\left(D\right)=\left\{d\right\}.$

• Substituting the sets:

• $\mathtt{Leftmost}\left(S\right)=\left\{a\right\}.$
• $\mathtt{Leftmost}\left(A\right)=\left\{a\right\}.$
• $\mathtt{Leftmost}\left(B\right)=\left\{b\right\}.$
• $\mathtt{Leftmost}\left(C\right)=\left\{c\right\}.$
• $\mathtt{Leftmost}\left(D\right)=\left\{d\right\}.$

5.3.5. Case Studies

For Algorithm 5, the application of some precedence relations is exhibited.

• For the delimiter symbol $:

  (a)

  $\$⋖\mathcal{L}\left(S\right)\to$ Rule (A.1).

  • $\$⋖a$
  • $\$⋖b$
  • $\$⋖d$
  • $\$⋖c$

  (b)

  $\mathcal{R}\left(S\right)⋗\$\to$ Rule (A.2).

  • $c⋗\$$

• For $S⟶ABC$

  (a)

  $X=A,Y=B\to$ Rule (E.1).

  $\mathcal{R}\left(A\right)⋗{\mathcal{L}}_m\left(B\right)$

  • $a⋗b$

  $u=null,l=\left[A\right]$

  (b)

  $X=B,Y=C\to$ Rule (E.1).

  $\mathcal{R}\left(B\right)⋗{\mathcal{L}}_m\left(C\right)$

  • $b⋗c$

  $A\in l\ne \left[\right]\to$ Rule (E.3).

  $\mathcal{R}\left(A\right)⋗{\mathcal{L}}_m\left(C\right)$

  • $a⋗c$

  $u=null,l=\left[\right]$

• For $A⟶aA$

  (a)

  $X=a,Y=A\to$ Rule (C).

  $a⋖\mathcal{L}\left(A\right)$

  • $a⋖a$

  $u=a,l=\left[\right]$

• For $B⟶bB$

  (a)

  $X=b,Y=B\to$ Rule (C).

  $b⋖\mathcal{L}\left(B\right)$

  • $b⋖b$

  $u=b,l=\left[\right]$

• For $C⟶CDc$

  (a)

  $X=C,Y=D\to$ Rule (E.1).

  $\mathcal{R}\left(C\right)⋗{\mathcal{L}}_m\left(D\right)$

  • $c⋗d$

  $u=null,l=\left[\right]$

  (b)

  $X=D,Y=c\to$ Rule (D.1).

  $\mathcal{R}\left(D\right)⋗c$

  • $d⋗c$

  $u=null,l=\left[\right]$

• In the following cases, the form $XY$ is not fulfilled in the right side part of the production; therefore, no rule can be applied:

  (a)

  $A⟶a$

  (b)

  $B⟶b$

  (c)

  $B⟶\epsilon$

  (d)

  $C⟶c$

  (e)

  $D⟶d$

The remaining precedence relations are derived using the same method as the previously demonstrated cases.

5.3.6. Operator Precedence Table

At the end of the algorithm execution, operator precedence

Table 16. Precedence Table of Example 3.

	a	b	c	d	$
a	⋖	⋗	⋗
b		⋖	⋗
c				⋗	⋗
d			⋗
$	⋖	⋖	⋖	⋖

is obtained.

5.3.7. Bottom-Up Parsing

Let $aabbcdc$ be a string obtained by rightmost derivation, then applying Algorithm 1 results in the bottom-up parsing detailed in

Table 17. Bottom-up Parsing of Example 3.

Stack	Input	Action
$	$aabbcdc\$$	Shift
$\$a$	$abbcdc\$$	Shift
$\$aa$	$bbcdc\$$	Reduce
$\$a$	$bbcdc\$$	Reduce
$	$bbcdc\$$	Shift
$\$b$	$bcdc\$$	Shift
$\$bb$	$cdc\$$	Reduce
$\$b$	$cdc\$$	Reduce
$	$cdc\$$	Shift
$\$c$	$dc\$$	Reduce
$	$dc\$$	Shift
$\$d$	$c\$$	Reduce
$	$c\$$	Shift
$\$c$	$	Reduce
$	$	Accept

.

5.4. Discussion

In the examples, three CFGs are considered: one OPG and two non-OPGs. In the first CFG, it is observed that it complies with the basic rule, while the following ones do not since they present productions with consecutive non-terminal symbols on the right side. Regardless of the nature of the CFG, the proposed algorithms play a crucial role in obtaining the operator precedence table. Using Algorithm 1 applied to a specific string for each CFG, a bottom-up parsing is performed, verifying that the strings are generated by their respective grammars. This process underscores the functionality of the proposal to perform bottom-up parsing based on operator precedence, even when the CFGs do not fulfill the basic requirement of the OPGs.

6. Exceptions

If the CFG has any of the following forms, the rules outlined in the algorithms of this paper would not apply:

• $A⟶aBb$
  $B⟶\beta a$
  The sets for B in the second production are:
  $\mathcal{L}\left(B\right)=\left\{a\right\}$.
  $\mathcal{R}\left(B\right)=\left\{a\right\}$.
  The precedence relations based on the sections of Algorithm 5 exhibit:
  • For the rule (C): $a⋖a$ and $u=a$.
  • For the rule (D.1): $a⋗b$.
  • For the rule (D.2): $a\doteq b$.
  Applying rules (D.1) and (D.2) generates the conflict.
• $A⟶aBb$
  $B⟶a\beta$
  Being $\beta \stackrel{\ast }{⟹}\epsilon \vee \beta \stackrel{\ast }{⟹}\gamma a$.
  According to the established conditions, the sets for B in the second production are
  $\mathcal{L}\left(B\right)=\left\{a\right\}$.
  $\mathcal{R}\left(B\right)=\left\{a\right\}$.
  The precedence relations based on the sections of Algorithm 5 exhibit:
  • For the rule (C): $a⋖a$ and $u=a$.
  • For the rule (D.1): $a⋗b$.
  • For the rule (D.2): $a\doteq b$.
  The application of rules (D.1) and (D.2) generates the conflict.
  If the $\mathcal{R}\left(B\right)$ does not contain a, then the conflict does not arise.
• $A⟶bBa$
  $B⟶a\beta$
  The sets for B in the second production are:
  $\mathcal{L}\left(B\right)=\left\{a\right\}$.
  $\mathcal{R}\left(B\right)=\left\{a\right\}$.
  The precedence relations based on the sections of Algorithm 5 exhibit:
  • For the rule (C): $b⋖a$ and $u=b$.
  • For the rule (D.1): $a⋗a$.
  • For the rule (D.2): $b\doteq a$.
  The application of rules (C) and (D.2) generates the conflict.
• $A⟶bBa$
  $B⟶\beta a$
  Being $\beta \stackrel{\ast }{⟹}\epsilon \vee \beta \stackrel{\ast }{⟹}a\gamma$.
  According to the established conditions, the sets for B in the second production are:
  $\mathcal{L}\left(B\right)=\left\{a\right\}$.
  $\mathcal{R}\left(B\right)=\left\{a\right\}$.
  The precedence relations based on the sections of Algorithm 5 exhibit:
  • For the rule (C): $b⋖a$ and $u=b$.
  • For the rule (D.1): $a⋗a$.
  • For the rule (D.2): $b\doteq a$.
  The application of rules (C) and (D.2) generates the conflict.
  If the $\mathcal{L}\left(B\right)$ does not contain a, then the conflict does not arise.

• When CFG productions take the following form, there will be no conflicts:
• $A⟶aBb$
• $B⟶\gamma$
• where $\gamma$ has neither a at the end of the right side nor b at the end of the left side.

7. Conclusions

Previous work has addressed the application of OPGs to solve problems related to the parsing of various forms of languages; however, not much emphasis has been placed on the definition of the Left and Right sets nor on the generation of an algorithm to find the operator precedence table.

In this work, we have redefined the sets Right and Left, previously exposed by other authors, and introduced a novel set called Leftmost. These sets form the basis for an algorithm that constructs the operator precedence table. Each set is constructed from an algorithm that facilitates its obtaining, adding a new dimension to the existing research.

The proposed algorithm for constructing the precedence table, while breaking (with some exceptions) the basic definition of an OPG, opens up new possibilities. It allows for the construction of an operator precedence table from a non-OPG CFG, paving the way for a bottom-up parsing algorithm to recognize a string generated by the CFG.

Three examples of CFGs are shown: one OPG and two non-OPGs. The proposed algorithms are systematically applied to these examples, step by step, until the operator precedence tables are obtained, regardless of the CFG’s nature. Additionally, the bottom-up parsing algorithm is applied to specific strings for each grammar, providing verification that they generated them.

It is important to note that while the algorithm and the definition of the new sets of terminal symbols are significant advancements, they do have limitations. It is not always possible to solve all cases where two or more adjacent terminal symbols are on the right-hand side. There are exceptions, and we must be aware of them.