I need help integrating a code generator $($outputs a $.$o object code of the C code read from a txt$)$into this lexical, sintaxis and semantic analyzer: import re

import tkinter as tk

from tkinter import filedialog, Text

import pandas as pd

import numpy as np

# Lexical Analyzer

LEXER$\_$TABLE $=$ pd$.$DataFrame$($columns$=[\text{'}$TOKEN$\text{'},$ 'IDENTITY'$],$ index$=$range$(1))$

def lexer$($code$)$:

SYMBOLS $=[\text{'}(\text{'},\text{'})\text{'},\text{'}$;$\text{'},\text{'},\text{'},\text{'}$:$\text{'},\text{'}\backslash \text{'}\text{'}]$

SYMBOLS$\_1=[\text{'}(\text{'},\text{'})\text{'},\text{'}$;$\text{'},\text{'},\text{'},\text{'}$:$\text{'},\text{'}\backslash \text{'}\text{'},\text{'}+\text{'},\text{'}=\text{'},\text{'}>\text{'}]$

SYMBOLS$\_1\_$DUP $=[[\text{'}$Open bracket', $\text{'}(\text{'}],[\text{'}$Close bracket', $\text{'})\text{'}],[\text{'}$Semi colon', $\text{'}$;$\text{'}],$

$[\text{'}$Comma$\text{'},\text{'},\text{'}],[\text{'}$Colon$\text{'},\text{'}$:$\text{'}],[\text{'}$Single quote', $\text{'}\backslash \text{'}\text{'}],[\text{'}$plus$\text{'},\text{'}+\text{'}],$

$[\text{'}$equal$\text{'},\text{'}=\text{'}],[\text{'}$greater$\text{'},\text{'}>\text{'}]]$

keywords $=[\text{'}$integer$\text{'},$ 'main', 'while', 'begin', 'end', 'expr', $\text{'}\text{'},\text{'}$

$\text{'},$ 'Procedure',

$\text{'}$If$\text{'},$ 'elseif', 'else', 'then', 'printf', 'and', $\text{'}$or$\text{'}]$

keywords$\_$def $=[[\text{'}$t$\text{'},$ 'integer'$],[\text{'}$m$\text{'},$ 'main'$],[\text{'}$l$\text{'},$ 'while'$],[\text{'}$b$\text{'},$ 'begin'$],[\text{'}$d$\text{'},$ 'end'$],$

$[\text{'}$e$\text{'},$ 'expr'$],[\text{'}$s$\text{'},\text{'}\text{'}],[\text{'}$o$\text{'},\text{'}+\text{'}],[\text{'}$o$\text{'},\text{'}=\text{'}],[\text{'}$n$\text{'},\text{'}$

$\text{'}],[\text{'}$p$\text{'},$ 'Procedure'$],$

$[\text{'}$x$\text{'},\text{'}$If$\text{'}],[\text{'}$z$\text{'},$ 'elseif'$],[\text{'}$y$\text{'},$ 'else'$],[\text{'}$f$\text{'},$ 'then'$],[\text{'}$c$\text{'},$ 'printf'$],$

$[\text{'}$&$\text{'},$ 'and'$],[\text{'}|\text{'},\text{'}$or$\text{'}],[\text{'}$o$\text{'},\text{'}>\text{'}]]$

KEYWORDS $=$ SYMBOLS$\_1+$ keywords

white$\_$space $=\text{'}\text{'}$

lexeme $=\text{'}\text{'}$

tokens $=[]$

code $=$ code.replace$(\text{'}\backslash$t$\text{'},\text{'}\text{'})$

for i$,$ char in enumerate$($code$)$:

if char $!=$ white$\_$space:

lexeme $+=$ char

if $($i $+1<$ len$($code$))$:

if code$[$i $+1]==$ white$\_$space or code$[$i $+1]$ in KEYWORDS or lexeme in KEYWORDS:

if lexeme $!=\text{'}\text{'}$:

tokens.append$($lexeme$.$replace$(\text{'}$

$\text{'},\text{'}\text{'}))$

lexeme $=\text{'}\text{'}$

j $=0$

for i in tokens:

for k in SYMBOLS$\_1\_$DUP:

if i $==$ k$[1]$:

LEXER$\_$TABLE.at$[$j$,$ 'TOKEN'$]=$ i

LEXER$\_$TABLE.at$[$j$,$ 'IDENTITY'$]=$ k$[0]$

j $+=1$

break

if i in keywords:

LEXER$\_$TABLE.at$[$j$,$ 'TOKEN'$]=$ i

LEXER$\_$TABLE.at$[$j$,$ 'IDENTITY'$]=$ 'Keyword'

j $+=1$

continue

if i$.$isdigit$()$:

LEXER$\_$TABLE.at$[$j$,$ 'TOKEN'$]=$ i

LEXER$\_$TABLE.at$[$j$,$ 'IDENTITY'$]=$ 'Digit'

j $+=1$

continue

elif i not in KEYWORDS:

LEXER$\_$TABLE.at$[$j$,$ 'TOKEN'$]=$ i

LEXER$\_$TABLE.at$[$j$,$ 'IDENTITY'$]=$ 'Identifier'

j $+=1$

print$($f$"$Lexer Tokens: $\{$tokens$\}")$ # Debugging output

return tokens

# Syntax and Semantic Analyzers $($Simplified Example$)$

EPSILON $="\backslash$epsi $"$

grammar $=[$

$"$S$->$E$",$

$"$E$->$E$+$T$",$

$"$E$->$T$",$

$"$T$->$T$*$F$",$

$"$T$->$F$",$

$"$F$->($E$)",$

$"$F$->$id$"$

$]$

def get$\_$productions$($X$)$:

productions $=[]$

for prod in grammar:

lhs$,$ rhs $=$ prod.split$(\text{'}->\text{'})$

if lhs $==$ X:

rhs $=\text{'}.\text{'}+$rhs

productions.append$(\text{'}->\text{'}.$join$([$lhs$,$ rhs$]))$

return productions

def closure$($I$)$:

for production, a in I:

if production.endswith$(".")$:

continue

lhs$,$ rhs $=$ production.split$(\text{'}->\text{'})$

alpha, B$\_$beta $=$ rhs$.$split$(\text{'}.\text{'})$

B $=$ B$\_$beta$[0]$

beta $=$ B$\_$beta$[1$:$]$

beta$\_$a $=$ a

if beta:

beta$\_$a $=$ beta$[0]+$a

first$\_$beta$\_$a $=$ first$($beta$\_$a$)$

for b in first$\_$beta$\_$a:

B$\_$productions $=$ get$\_$productions$($B$)$

for gamma in B$\_$productions:

new$\_$item $=($gamma$,$ b$)$

if $($new$\_$item not in I$)$:

I.append$($new$\_$item$)$

return I

def get$\_$symbols$($grammar$)$:

terminals $=$ set$()$

non$\_$terminals $=$ set$()$

for production in grammar:

lhs$,$ rhs $=$ production.split$(\text{'}->\text{'})$

non$\_$terminals.add$($lhs$)$

for x in rhs:

terminals.add$($x$)$

terminals $=$ terminals.difference$($non$\_$terminals$)$

terminals.add$(\text{'}$$$\text{'})$

return terminals, non$\_$terminals

def first$($symbols$)$:

final$\_$set $=$ set$()$

for X in symbols:

first$\_$set $=$ set$()$

if isTerminal$($X$)$:

final$\_$set.add$($X$)$

else:

for production in grammar:

lhs$,$ rhs $=$ production.split$(\text{'}->\text{'})$

if lhs $==$ X:

for i in range$($len$($rhs$))$:

y $=$ rhs$[$i$]$

if y $==$ X:

continue

first$\_$y $=$ first$($y$)$

if EPSILON in first$\_$y:

first$\_$y $=$ first$\_$y$.$replace$($EPSILON$,"")$

first$\_$set.add$($first$\_$y$)$

continue

else:

first$\_$set.add$($first$\_$y$)$

break

for i in first$\_$set:

if EPSILON not in i:

final$\_$set.add$($i$)$

else:

i $=$ i$.$replace$($EPSILON$,"")$

final$\_$set.add$($i$)$

return $"".$join$($list$($final$\_$set$))$

def isTerminal$($symbol$)$:

return symbol in terminals

def shift$\_$dot$($production$)$:

lhs$,$ rhs $=$ production.split$(\text{'}->\text{'})$

x$,$ y $=$ rhs$.$split$(".")$