Q1

#include <iostream>

#include <unordered_map>

#include <unordered_set>

#include <vector>

#include <string>

using namespace std;

// Define the grammar rules

unordered_map<string, vector<string>> grammar;

// Function to compute First sets

unordered_map<string, unordered_set<char>> firstSet;

// Function to compute Follow sets

unordered_map<string, unordered_set<char>> followSet;

// Function to calculate First set for a non-terminal

void computeFirst(string nonTerminal) {

if (firstSet.find(nonTerminal) != firstSet.end()) {

return; // If already computed

// Initialize the First set for the non-terminal

unordered_set<char> first;

for (const string& production : grammar[nonTerminal]) {

if (isupper(production[0])) {
 computeFirst(production); // Recursively compute First for non-
terminals

first.insert(firstSet[production].begin(), firstSet[production].end());

} else {

first.insert(production[0]); // Terminal symbol

firstSet[nonTerminal] = first;

// Function to compute Follow set for a non-terminal

void computeFollow(string nonTerminal) {

if (followSet.find(nonTerminal) != followSet.end()) {

return; // If already computed

unordered_set<char> follow;

// If nonTerminal is the start symbol, add '$' (end of input)

if (nonTerminal == "S") {

follow.insert('$');

for (auto& rule : grammar) {

string left = rule.first;

for (string production : rule.second) {

for (size_t i = 0; i < production.size(); i++) {

if (production[i] == nonTerminal[0]) { // If we find the non-

terminal
 if (i + 1 < production.size()) {

char nextSymbol = production[i + 1];

if (isupper(nextSymbol)) {

computeFirst(string(1, nextSymbol)); // Recursively

compute First

follow.insert(firstSet[string(1, nextSymbol)].begin(),
firstSet[string(1, nextSymbol)].end());

} else {

follow.insert(nextSymbol); // Terminal symbol

} else {

if (left != nonTerminal) {

computeFollow(left); // Follow the production rule's left-

hand side

follow.insert(followSet[left].begin(), followSet[left].end());

followSet[nonTerminal] = follow;

// Function to build the LL(1) parse table

unordered_map<string, unordered_map<char, string>> buildParseTable()

{

unordered_map<string, unordered_map<char, string>> parseTable;

 for (auto& rule : grammar) {

string nonTerminal = rule.first;

for (string production : rule.second) {

// For each production, we need to check the First set

if (production == "ε") {

for (char c : followSet[nonTerminal]) {

parseTable[nonTerminal][c] = nonTerminal + " → ε";

} else {

char firstSymbol = production[0];

if (isupper(firstSymbol)) {

for (char c : firstSet[string(1, firstSymbol)]) {

parseTable[nonTerminal][c] = nonTerminal + " → " +

production;

} else {

parseTable[nonTerminal][firstSymbol] = nonTerminal + " → "

+ production;

return parseTable;

// Function to display the parse table

void displayParseTable(unordered_map<string, unordered_map<char,

string>> parseTable) {

// Print the header row

 cout << "Non-terminal a b $ " << endl;

cout << "----------------------------------------" << endl;

// Print the parse table row by row

for (auto& entry : parseTable) {

cout << entry.first;

for (char terminal : {'a', 'b', '$'}) {

cout << " " << (entry.second.find(terminal) !=

entry.second.end() ? entry.second[terminal] : " ");

cout << endl;

int main() {

// Define grammar: S → aSb | ε

grammar["S"] = {"aSb", "ε"};

// Compute the First and Follow sets for all non-terminals

computeFirst("S");

computeFollow("S");

// Build the LL(1) parse table

unordered_map<string, unordered_map<char, string>> parseTable =

buildParseTable();

// Display the parse table

displayParseTable(parseTable);

return 0;
}

Bash

g++ ll1_parse_table.cpp -o parse_table

./parse_table

#include <iostream>

#include <unordered_map>

#include <string>

using namespace std;

// Function to display the parse table

void displayParseTable() {

// Create a map to represent the parse table

unordered_map<string, unordered_map<char, string>> parseTable;

// Fill the parse table with the given rules for S

parseTable["S"]['a'] = "S → aSb";

parseTable["S"]['b'] = "S → ε";

parseTable["S"]['$'] = "S → ε"; // '$' represents the end of input

// Print header row

cout << "Non-terminal a b $ " << endl;

cout << "----------------------------------------" << endl;

// Print the table for non-terminal 'S'

 cout << "S "

<< parseTable["S"]['a'] << " "

<< parseTable["S"]['b'] << " "

<< parseTable["S"]['$'] << endl;

int main() {

displayParseTable(); // Call the function to display the parse table

return 0;

Step-by-Step Guide:

1. Create a New C++ File in VS Code:

o Open Visual Studio Code (VS Code).

o Go to File > New File and save it as ll1_parse_table.cpp in the

desired directory.

2. Paste the Code:

o Copy the entire C++ code I provided in the earlier message.

o Paste it into your newly created .cpp file in VS Code.

3. Open the Integrated Terminal in VS Code:

o In VS Code, press Ctrl + ` (backtick) or go to the Terminal >

New Terminal option to open the terminal.

4. Navigate to the File's Directory (if needed):

o If your C++ file is located in a folder, use the cd command in

the terminal to navigate to the folder where the .cpp file is
saved:

bash

Copy

cd path/to/your/file

5. Compile the C++ Code:

 o In the terminal, type the following command to compile the
code:

bash

Copy

g++ ll1_parse_table.cpp -o parse_table

 g++: C++ compiler command.

 ll1_parse_table.cpp: Your C++ source code file.

 -o parse_table: Tells the compiler to output an

executable named parse_table.

6. Run the Executable:

o After the code compiles successfully, you will have an

executable named parse_table. To run it:

 On Linux/macOS:

bash

Copy

./parse_table

 On Windows:

bash

Copy

parse_table.exe

Expected Output:

If everything is set up correctly, after running the program, you should see
the following output in the terminal:

markdown

Copy

Non-terminal a b $

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

S S → aSb S → ε S → ε

This indicates that the LL(1) parse table has been generated correctly,
showing the production rules for the S non-terminal based on the input
symbols.
Troubleshooting:

 If you see errors during compilation, check that you have g++
installed and properly configured.

 Missing symbols or syntax errors: If there's any issue with

syntax or compilation, the error message will point to the
problematic line. You can fix it by reviewing the code closely or
sharing the error message for more help.

Let me know if you run into any specific errors!

Attach

Search

Reason