Review Lexical Analysis and Example Source Code given $,$ and then

implement a lexical analyzer that reads its input from a file and recognizes only arithmetic

expressions, including variable names and $64-$bit integer literals as operands. Write your

program in Python.

a$.$ Simple library function is acceptable; however, you should not use any library function

that significantly reduces workload $($e$.$g$.,$ java.util.regex$)$

$$ Variable names

o consist of strings of uppercase letters, lowercase letters, and digits but must begin

with a letter.

o have no length limitation$.$

$$ Arithmetic Expression may have the following operators: $+,-,*,/.$

Output:

$$ Token, Lexeme pair like the example in the class.

$/*$ front.c $-$ a lexical analyzer system for simple

arithmetic expressions $*/$

#include

#include

$/*$ Global declarations $*/$

$/*$ Variables $*/$

int charClass;

char lexeme $[100]$;

char nextChar;

int lexLen;

int token;

int nextToken;

FILE $*$in$\_$fp;

$/*$ Function declarations $*/$

void addChar$()$;

void getChar$()$;

void getNonBlank$()$;

int lex$()$;

$/*$ Character classes $*/$

#define LETTER $0$

#define DIGIT $1$

#define UNKNOWN $99$

$/*$ Token codes $*/$

#define INT$\_$LIT $10$

#define IDENT $11$

#define ASSIGN$\_$OP $20$

#define ADD$\_$OP $21$

#define SUB$\_$OP $22$

#define MULT$\_$OP $23$

#define DIV$\_$OP $24$

#define LEFT$\_$PAREN $25$

#define RIGHT$\_$PAREN $26$

$/******************************************************/$

$/*$ main driver $*/$

main$()\{$

$/*$ Open the input data file and process its contents $*/$

errno$\_$t err;

err $=$ fopen$\_$s$($&in$\_$fp$,"$D:$/$Academic$\_$Research$/$Course Teaching$/\_$Marshall$/$CS $300/$lecture slides$/$cs$300\_$lecture$\_07/$front$.$in$","$r$")$; $//$ If you face problem here, move the front.in file to a directory where the path does not have any space.

if $($err $!=0)$

printf$("$ERROR $-$ cannot open front.in

$")$;

else $\{$

getChar$()$;

do $\{$

lex$()$;

$\}$ while $($nextToken $!=$ EOF$)$;

$\}$

$\}$

$/*****************************************************/$

$/*$ lookup $-$ a function to lookup operators and parentheses

and return the token $*/$

int lookup$($char ch$)\{$

switch $($ch$)\{$

case $\text{'}(\text{'}$:

addChar$()$;

nextToken $=$ LEFT$\_$PAREN;

break;

case $\text{'})\text{'}$:

addChar$()$;

nextToken $=$ RIGHT$\_$PAREN;

break;

case $\text{'}+\text{'}$:

addChar$()$;

nextToken $=$ ADD$\_$OP;

break;

case $\text{'}-\text{'}$:

addChar$()$;

nextToken $=$ SUB$\_$OP;

break;

case $\text{'}*\text{'}$:

addChar$()$;

nextToken $=$ MULT$\_$OP;

break;

case $\text{'}/\text{'}$:

addChar$()$;

nextToken $=$ DIV$\_$OP;

break;

default:

addChar$()$;

nextToken $=$ EOF;

break;

$\}$

return nextToken;

$\}$

$/*****************************************************/$

$/*$ addChar $-$ a function to add nextChar to lexeme $*/$

void addChar$()\{$

if $($lexLen

lexeme$[$lexLen$++]=$ nextChar;

lexeme$[$lexLen$]=0$;

$\}$

else

printf$("$Error $-$ lexeme is too long

$")$;

$\}$

$/*****************************************************/$

$/*$ getChar $-$ a function to get the next character of

input and determine its character class $*/$

void getChar$()\{$

if $(($nextChar $=$ getc$($in$\_$fp$))!=$ EOF$)\{$

if $($isalpha$($nextChar$))$

charClass $=$ LETTER;

else if $($isdigit$($nextChar$))$

charClass $=$ DIGIT;

else charClass $=$ UNKNOWN;

$\}$

else

charClass $=$ EOF;

$\}$

$/*****************************************************/$

$/*$ getNonBlank $-$ a function to call getChar until it

returns a non$-$whitespace character $*/$

void getNonBlank$()\{$

while $($isspace$($nextChar$))$

getChar$()$;

$\}$

$/*****************************************************/$

$/*$ lex $-$ a simple lexical analyzer for arithmetic

expressions $*/$

int lex$()\{$

lexLen $=0$;

getNonBlank$()$;

switch $($charClass$)\{$

$/*$ Parse identifiers $*/$

case LETTER:

addChar$()$;

getChar$()$;

while $($charClass $==$ LETTER $||$ charClass $==$ DIGIT$)\{$

addChar$()$;

getChar$()$;

$\}$

nextToken $=$ IDENT;

break;

$/*$ Parse integer literals $*/$

case DIGIT:

addChar$()$;

getChar$()$;

while $($charClass $==$ DIGIT$)\{$

addChar$()$;

getChar$()$;

$\}$

nextToken $=$ INT$\_$LIT;

break;

$/*$ Parentheses and operators $*/$

case UNKNOWN:

lookup$($nextChar$)$;

getChar$()$;

break;

$/*$ EOF $*/$

case EOF:

nextToken $=$ EOF;

lexeme$[0]=\text{'}$E$\text{'}$;

lexeme$[1]=\text{'}$O$\text{'}$;

lexeme$[2]=\text{'}$F$\text{'}$;

lexeme$[3]=0$;

break;

$\}/*$ End of switch $*/$

printf$("$Next token is: $\%$d$,$ Next lexeme is $\%$s

$",$

nextToken, lexeme$)$;

return nextToken;

$\}/*$ End of function lex $*/$

$($sum $+480000000000000000000000000000000000000000000000000000000000000000)/$ total