Add the following semantics $($context$-$sensitive$)$ specifications to the parsing

code in

Arithmetic operations are performed such that $a-b=$max$\{a-b,0\},$

division by zero gives the result $0$ and the remainder also $0.$

$+-*/\%$ mean addition, subtraction, multiplication, integer division, and

calculating the remainder.

:$=$ means assignment.

The declaration tab$(10$:$100)$ declares a tab array with $91$ elements indexed

from $10$ to $100.$ The identifier tab$($i$)$ refers to the i$-$th element of the tab

array. A declaration containing the first number greater than the second

should be reported as an error.

The FOR loop has a local iterator, which takes values from the value after

FROM to the value after TO in an interval of $+1$ or $-1$ if the word

DOWNTO is used.

The number of iterations of the FOR loop is set at the beginning and does

not change during its execution $($even if the values of the variables

determining the beginning and end of the loop change$).$

The FOR loop iterator cannot be modified inside the loop $($the compiler

should report an error in such a case$).$

The REPEAT$-$UNTIL loop ends when the condition written after UNTIL is

met $($the loop will execute at least once$).$

The READ statement reads the value from outside and substitutes it into

the variable and WRITE writes the value of the variable$/$number outside.

The remaining instructions are consistent with their meaning in most

programming languages.

import ply$.$yacc as yacc

import ply$.$lex as lex

# Code for lexical analysis:

tokens $=[$ # List with TOKENS names

'KEYWORD',

$\text{'}$ID$\text{'},$

'NUM',

$\text{'}$LBR$\text{'},\text{'}$RBR$\text{'},$

'COLON', 'SEMICOLON', 'COMMA',

'ASSIGN',

$\text{'}$EQ$\text{'},$ 'NEQ', 'LEQ', 'GEQ',

$\text{'}$LT$\text{'},\text{'}$GT$\text{'},$

'PLUS', 'MINUS', 'MULT', 'DIV', 'MOD'

$]$

reserved $=\{\text{'}$DECLARE$\text{'}$: 'DECLARE', # Created dictionary with KEYWORDS, with a rule that matches with the identifier

'BEGIN': 'BEGIN',

'END': 'END',

$\text{'}$IF$\text{'}$: $\text{'}$IF$\text{'},$

'THEN': 'THEN',

'ELSE': 'ELSE',

'ENDIF': 'ENDIF',

$\text{'}$DO$\text{'}$: $\text{'}$DO$\text{'},$

'FOR': 'FOR',

'FROM': 'FROM',

$\text{'}$TO$\text{'}$: $\text{'}$TO$\text{'},$

'DOWNTO': 'DOWNTO',

'ENDFOR': 'ENDFOR',

'WHILE': 'WHILE',

'REPEAT': 'REPEAT',

'UNTIL': 'UNTIL',

'ENDWHILE': 'ENDWHILE',

'READ': 'READ',

'WRITE': 'WRITE'$\}$

# Regular expression rules for tokens

t$\_$LBR $=$ r$\text{'}\backslash (\text{'}$

t$\_$RBR $=$ r$\text{'}\backslash )\text{'}$

t$\_$COLON $=$ r$\text{'}$:$\text{'}$

t$\_$SEMICOLON $=$ r$\text{'}$;$\text{'}$

t$\_$COMMA $=$ r$\text{'},\text{'}$

t$\_$ASSIGN $=$ r$\text{'}$:$=\text{'}$

t$\_$EQ $=$ r$\text{'}=\text{'}$

t$\_$NEQ $=$ r$\text{'}!=\text{'}$

t$\_$LEQ $=$ r

t$\_$GEQ $=$ r$\text{'}>=\text{'}$

t$\_$LT $=$ r$\text{'}<mi>\text{'}</mi>$

t$\_$GT $=$ r$\text{'}>\text{'}$

t$\_$PLUS $=$ r$\text{'}\backslash +\text{'}$

t$\_$MINUS $=$ r$\text{'}-\text{'}$

t$\_$MULT $=$ r$\text{'}\backslash *\text{'}$

t$\_$DIV $=$ r$\text{'}/\text{'}$

t$\_$MOD $=\text{'}\%\text{'}$

t$\_$ignore $=\text{'}\backslash$t$\text{'}$ # Lexer ignores spaces

tokens $=$ tokens $+$ list$($reserved$.$values$())$ # Keywords are defined as tokens too

def t$\_$KEYWORD$($t$)$: # Defined a rule to track KEYWORDS.

r$\text{'}[$A$-$Z$][$A$-$Z$]*\text{'}$ # A string with one or more uppercase letters

t$.$type $=$ reserved.get$($t$.$value, 'KEYWORD'$)$

return t

def t$\_$ID$($t$)$: # Defined rule to track IDs

r$\text{'}[$a$-$z$][$a$-$z$\_0-9]*\text{'}$ # String with one or more consecutive lowercase letters

t$.$type $=\text{'}$ID$\text{'}$

return t

def t$\_$NUM$($t$)$: # Defined to identify numbers

r$\text{'}\backslash$d$+\text{'}$ # A digit or a repetition of digits

t$.$value $=$ int$($t$.$value$)$

return t

def t$\_$COMMENT$($t$)$: # Defined so lexer ignores comments

r$\text{'}\backslash /\backslash /(.*)$$$\text{'}$

pass

def t$\_$newline$($t$)$: # Tracks the number of lines

r$\text{'}$

$+\text{'}$

t$.$lexer.lineno $+=$ len$($t$.$value$)$

def t$\_$error$($t$)$: # Defined rule to identify errors

print$("$Illegal character $\text{'}\%$s$\text{'}"\%$ t$.$value$[0])$

t$.$lexer.skip$(1)$

lexer $=$ lex.lex$()$ # Created lexer

print$("$Name of file for lexical analysis and parsing:"$)$

textName $=$ input$()$ # Input of the name of the file, as one should try different files

textFile $=$ open$($textName$,\text{'}$r$\text{'})$ # Opens text file

data $=$ textFile.read$()$ # Data that is going to be used on the lexer

lexer.input$($data$)$ # Entered the data in the lexer

# While loop to tokenize$($Identify token, value, row and length

while True:

toke $=$ lexer.token$()$

if not toke:

break

print$($toke$)$

parsing$\_$successful $=$ True # Flag to indicate parsing success, so it only prints when parsing is successful

def p$\_$program$($p$)$: # Define instructions for prgram

$"""$program : DECLARE declarations BEGIN commands END

$|$ BEGIN commands END"""

def p$\_$declarations$($p$)$: # Define instructions for declarations

$"""$ declarations : declarations COMMA ID

$|$ declarations COMMA ID LBR NUM COLON NUM RBR

$|$ ID

$|$ ID LBR NUM COLON NUM RBR$"""$

def p$\_$commands$($p$)$: # Define instructions for commands

$"""$commands : commands command

$|$ command $"""$

def p$\_$command$($p$)$: # Define instructions for command, that are used in commands

$"""$command : identifier ASSIGN ex