EXPERIMENT-1(A)
AIM: Practice LEX Of Compiler Writing.
THEORY:
LEX program to count the number of words:
Code:
%{
#include<stdio.h> #include<string.h>
int i = 0;
%}
/* Rules Section*/
%%
([a-zA-Z0-9])* {i++;} /* Rule for counting number of words*/
"\n" {printf("%d\n", i); i = 0;}
%%
int yywrap(void){} int
main()
// The function that starts the
analysis yylex(); return 0;
OUTPUT:
LEX program to count the number of vowels and consonants in a string.
Code: %{ int
vow_count=0; int
const_count =0;
%}
%%
[aeiouAEIOU] {vow_count++;}
[a-zA-Z] {const_count++;}
%%
int yywrap(){}
int main()
printf("Enter the string of vowels and consonants:");
yylex();
printf("Number of vowels are: %d\n", vow_count);
printf("Number of consonants are: %d\n", const_count);
return 0;
}
EXPERIMENT-1(B)
AIM: Practice YACC Of Compiler Writing.
THEORY:
YACC program to implement a Calculator and recognize a valid Arithmetic
expression.
Code:
Lexical Analyzer Source Code:
%{
/* Definition section */
#include<stdio.h>
#include "y.tab.h"
extern int yylval;
%}
/* Rule Section */
%%
[0-9]+ {
yylval=atoi(yytext);
return NUMBER;
[\t] ;
[\n] return 0;
. return yytext[0];
%%
int yywrap()
return 1;
}
Parser Source Code:
%{
/* Definition section */
#include<stdio.h> int
flag=0;
%}
%token NUMBER
%left '+' '-'
%left '*' '/' '%'
%left '(' ')'
/* Rule Section */
%%
ArithmeticExpression: E{
printf("\nResult=%d\n", $$);
return 0;
};
E:E'+'E {$$=$1+$3;}
|E'-'E {$$=$1-$3;}
|E'*'E {$$=$1*$3;}
|E'/'E {$$=$1/$3;}
|E'%'E {$$=$1%$3;}
|'('E')' {$$=$2;}
| NUMBER {$$=$1;}
%%
//driver code
void main()
{
printf("\nEnter Any Arithmetic Expression :\n"); yyparse(); if(flag==0)
printf("\nEntered arithmetic expression is Valid\n\n");
void yyerror()
printf("\nEntered arithmetic expression is Invalid\n\n");
flag=1;
OUTPUT:
EXPERIMENT-2
AIM: Write a program to check whether a string belongs to the grammar
or not.
THEORY:
CODE:
import ply.lex as lex
import ply.yacc as yacc
# Define tokens
tokens = (
'A',
'B',
)
# Regular expression rules for tokens
t_A = r'a'
t_B = r'b'
# Ignored characters
t_ignore = ' \t\n'
# Error handling rule for invalid characters
def t_error(t):
print(f"Illegal character '{t.value[0]}'")
t.lexer.skip(1)
# Define the lexer
lexer = lex.lex()
# Define the CFG grammar
def p_start(p):
'''
start : equal_ab
| non_equal_ab
| empty
'''
pass
def p_equal_ab(p):
'''
equal_ab : equal_ab A B
| equal_ab B A
| AB
'''
pass
def p_non_equal_ab(p):
'''
non_equal_ab : non_equal_ab A
| non_equal_ab B
| BA
'''
pass
def p_AB(p):
'''
AB : A B
'''
pass
def p_BA(p):
'''
BA : B A
'''
pass
def p_empty(p):
'empty :'
pass
# Error handling rule for syntax errors
def p_error(p):
raise Exception("Syntax error in input!")
# Create the parser
parser = yacc.yacc()
# Function to check if a string belongs to the grammar
def check_string(input_string):
lexer.input(input_string)
try:
parser.parse(lexer=lexer)
return f"'{input_string}' belongs to the grammar."
except Exception as e:
return f"'{input_string}' does not belong to the grammar: {e}"
# Test the program
while True:
input_string = input("Enter a string (or 'exit' to quit): ")
if input_string.lower() == 'exit':
break
result = check_string(input_string)
print(result)
OUTPUT:
EXPERIMENT-3
AIM: Write a program to check whether a string includes a keyword or
not.
THEORY:
CODE:
import ply.lex as lex
import ply.yacc as yacc
# Define the list of keywords you want to check for
keywords = {'if', 'else', 'while', 'for', 'break', 'continue', 'return'}
# Define the list of tokens
tokens = ['ID'] + [keyword.upper() for keyword in keywords]
# Regular expression rules for tokens
t_ignore = ' \t\n'
# Define a rule to match keywords
def t_KEYWORD(t):
r'(if|else|while|for|break|continue|return)'
t.type = t.value.upper() # Convert keyword to uppercase
return t
# Error handling rule for invalid characters
def t_error(t):
print(f"Illegal character '{t.value[0]}'")
t.lexer.skip(1)
# Build the lexer
lexer = lex.lex()
# Define the grammar for an input containing keywords
def p_input(p):
'''
input : statement
| empty
'''
pass
def p_statement(p):
'''
statement : ID
| IF
| ELSE
| WHILE
| FOR
| BREAK
| CONTINUE
| RETURN
'''
print(f"'{p[1]}' is a keyword")
def p_empty(p):
'empty :'
pass
# Error handling rule for syntax errors
def p_error(p):
print(f"Syntax error at '{p.value}'")
# Build the parser
parser = yacc.yacc()
# Function to check for keywords in an input string
def check_keywords(input_string):
parser.parse(input_string, lexer=lexer)
# Test the program
while True:
input_string = input("Enter an input string (or 'exit' to quit): ")
if input_string.lower() == 'exit':
break
check_keywords(input_string)
OUTPUT:
EXPERIMENT-4
AIM: Write a program to remove left recursion from a Grammar.
THEORY:
CODE:
import ply.lex as lex
import ply.yacc as yacc
# Lexer tokens
tokens = (
'ID', # Non-terminals
'ARROW', # Arrow (->)
'OR', #|
)
# Token regex rules
t_ARROW = r'->'
t_OR = r'\|'
# Ignore spaces and tabs
t_ignore = " \t"
# Rule for non-terminal IDs (single uppercase letter)
def t_ID(t):
r'[A-Z]'
return t
# Rule for new lines
def t_newline(t):
r'\n+'
t.lexer.lineno += len(t.value)
# Error handling
def t_error(t):
print(f"Illegal character '{t.value[0]}'")
t.lexer.skip(1)
# Build the lexer
lexer = lex.lex()
# Dictionary to store grammar rules
grammar = {}
def p_grammar(p):
"""grammar : grammar production
| production"""
pass
def p_production(p):
"""production : ID ARROW rules"""
non_terminal = p[1]
grammar[non_terminal] = p[3]
def p_rules(p):
"""rules : rules OR rule
| rule"""
if len(p) == 4:
p[0] = p[1] + [p[3]]
else:
p[0] = [p[1]]
def p_rule(p):
"""rule : ID"""
p[0] = p[1]
def p_epsilon(p):
"""rule : epsilon"""
p[0] = []
def p_error(p):
if p:
print(f"Syntax error at '{p.value}'")
else:
print("Syntax error at EOF")
# Build the parser
parser = yacc.yacc()
# Function to remove left recursion from the grammar
def remove_left_recursion(grammar):
new_grammar = {}
for non_terminal, productions in grammar.items():
alpha_productions = []
beta_productions = []
new_non_terminal = non_terminal + "'"
for production in productions:
if production.startswith(non_terminal):
alpha_productions.append(production[len(non_terminal):] + new_non_terminal)
else:
beta_productions.append(production + new_non_terminal)
if alpha_productions:
new_grammar[non_terminal] = [beta + new_non_terminal for beta in beta_productions]
new_grammar[new_non_terminal] = [alpha for alpha in alpha_productions] + ['ε']
else:
new_grammar[non_terminal] = productions
return new_grammar
# Function to print the grammar
def print_grammar(grammar):
for non_terminal, productions in grammar.items():
print(f"{non_terminal} -> {' | '.join(productions)}")
if __name__ == "__main__":
input_data = """
A -> A a | B
B -> b
"""
lexer.input(input_data)
# Parsing the grammar
parser.parse(input_data)
print("Original Grammar:")
print_grammar(grammar)
new_grammar = remove_left_recursion(grammar)
print("\nGrammar after removing left recursion:")
print_grammar(new_grammar)
OUTPUT:
