Please provide the complete Python code for the following:
You have already implemented a lexical analyzer in Assignment #1 and a parser to recognize grammatical rules in Assignment #2. In this assignment, you will be adding semantics to the design of a small programming language to help implement blockchain using Python.
The semantics that you must implement in this assignment is as follows:
1. Each time a new blockchain is created, you must extract attributes and verifies if each attribute has a valid type. Returns false if at least one is invalid or returns true otherwise.
2.When the add operator (keyword) is used, the data must be stored in a dictionary .
3. When errors are detected, the parser must describe the error, including the line of the code where it occurs.
4.When arithmetic expressions are used, the parser will implement the corresponding arithmetic operations. For simplicity purposes, the blockchain only will store arithmetic expressions and strings.
A few additional instructions:
1. Create your own testing file with lexical, syntax, and semantics errors that your parser implementation can detect.
Assignment 1 Code:
import ply.lex as lex
class Lexer:
tokens = [
'ID', 'BLOCK', 'VAR', 'ADD', 'PRINT', 'VIEW',
'RUN', 'MINE', 'EXPORT', 'STR', 'INT', 'LONG',
'FLOAT', 'LIST', 'TUPLE', 'DICT', 'NUM', 'ASSIGN',
'TYPEASSIGN', 'SEPARATOR', 'LPAREN', 'RPAREN', 'NE',
'LT', 'GT', 'LE', 'GE', 'PLUS', 'MINUS', 'STAR', 'SLASH',
'COMMENT', 'WHITESPACE', 'PCT'
]
keywords = [
'block', 'var', 'add', 'print', 'view', 'run', 'mine',
'export', 'str', 'int', 'long', 'float', 'List',
'Tuple', 'Dict'
]
t_ASSIGN = r'='
t_TYPEASSIGN = r':'
t_SEPARATOR = r','
t_LPAREN = r'\('
t_RPAREN = r'\)'
t_NE = r'!='
t_LT = r'<'
t_GT = r'>'
t_LE = r'<='
t_GE = r'>='
t_PLUS = r'\+'
t_MINUS = r'-'
t_STAR = r'\*'
t_SLASH = r'/'
t_PCT = r'%'
def __init__(self):
self.lexer = None
def t_newline(self, t):
r'\\'
t.lexer.lineno += 1
pass
def t_COMMENT(self, t):
r'//[^\\]*'
pass
def t_WHITESPACE(self, t):
r'[ \t\r]+'
pass
def t_ID(self, t):
r'[a-zA-Z_][a-zA-Z_0-9]*'
if t.value in self.keywords:
t.type = t.value.upper()
return t
def t_NUM(self, t):
r'\d+'
t.value = int(t.value)
return t
def t_error(self, t):
print("Illegal character '%s'" % t.value[0])
t.lexer.skip(1)
def build(self, **kwargs):
self.lexer = lex.lex(module=self, **kwargs)
def test(self, data):
self.lexer.input(data)
while True:
token = self.lexer.token()
if not token: break
print(token)
textFile = open('test_file.txt', 'r')
data = textFile.read()
test_out = Lexer()
test_out.build()
test_out.test(data)
Assignment 2 Code:
import ply.yacc as yacc
import Assignment1
tokens = Assignment1.Lexer.tokens
precedence = (('MINUS', 'left', 'PLUS'),)
def p_block(p):
'''block : BLOCK ID ASSIGN LPAREN attributes RPAREN
| ADD ID ASSIGN LPAREN new_atts RPAREN
| VAR ID
| PRINT ID
| RUN ID
| MINE ID
| EXPORT ID
| VIEW ID'''
p[0] = tuple(p[1:])
def p_type(p):
'''type : STR
| INT
| LONG
| FLOAT
| LIST
| TUPLE
| DICT '''
p[0] = p[1]
def p_attribute(p):
'''attribute : ID TYPEASSIGN type'''
p[0] = (p[1], p[3])
def p_attributes(p):
'''attributes : attribute
| attributes SEPARATOR attribute '''
if len(p) == 2:
p[0] = [p[1]]
else:
p[1].append(p[3])
p[0] = p[1]
def p_new_att(p):
'''new_att : ID TYPEASSIGN STR
| ID TYPEASSIGN NUM '''
p[0] = (p[1], p[3])
def p_new_attS(p):
'''new_atts : new_att
| new_atts SEPARATOR new_att '''
if len(p) == 2:
p[0] = [p[1]]
else:
p[1].append(p[3])
p[0] = p[1]
def p_expr(p):
'''expr : term
| expr PLUS term
| expr MINUS term '''
if len(p) == 2:
p[0] = p[1]
elif p[2] == '+':
p[0] = p[1] + p[3]
elif p[2] == '-':
p[0] = p[1] - p[3]
def p_term(p):
''' term : factor
| term STAR factor
| term SLASH factor
| term PCT factor'''
if len(p) == 2:
p[0] = p[1]
elif p[2] == '*':
p[0] = p[1] * p[3]
elif p[2] == '/':
p[0] = p[1] / p[3]
elif p[2] == '%':
p[0] = p[1] % p[3]
def p_factor(p):
'''factor : ID
| NUM
| LPAREN expr RPAREN
| factor LPAREN argsopt RPAREN '''
if len(p) == 2:
p[0] = p[1]
elif len(p) == 4:
p[0] = p[2]
def p_test(p):
'''test : expr NE expr
| expr LT expr
| expr LE expr
| expr GE expr
| expr GT expr'''
if p[2] == '!=':
p[0] = p[1] != p[3]
elif p[2] == '<':
p[0] = p[1] < p[3]
elif p[2] == '<=':
p[0] = p[1] <= p[3]
elif p[2] == '>=':
p[0] = p[1] >= p[3]
elif p[2] == '>':
p[0] = p[1] > p[3]
def p_empty(p):
'empty : '
def p_argsopt(p):
'''argsopt : args
| empty'''
p[0] = p[1] if len(p) == 2 else []
def p_args(p):
''' args : expr SEPARATOR args
| expr'''
p[0] = [p[1]]
if len(p) > 2:
p[0] += p[3]
def p_error(p):
print("Syntax error at token", p, "line:", p.lexer.lineno)
textFile = open('file.txt', 'r')
data = textFile.read()
parser = yacc.yacc()
result = parser.parse(data)
print(result)