Scribd
Upload
3K views

LL1 Parser Implementation in C

This document contains code to implement an NFA to DFA conversion algorithm in C. It defines structs for the DFA states and productions. It reads the NFA transition table as input and calculates the epsilon-closure of each state to generate the DFA states. For each DFA state, it iterates through the symbols to determine the transition function and checks for new DFA states. Finally, it displays the generated DFA transition table.

Uploaded by

verma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
3K views

LL1 Parser Implementation in C

This document contains code to implement an NFA to DFA conversion algorithm in C. It defines structs for the DFA states and productions. It reads the NFA transition table as input and calculates the epsilon-closure of each state to generate the DFA states. For each DFA state, it iterates through the symbols to determine the transition function and checks for new DFA states. Finally, it displays the generated DFA transition table.

Uploaded by

verma
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

LL1 parser implementation in c

#include<stdio.h>
#include<string.h>
struct production
{
char variable;
char value[10][100];
};
int main()
{
char variable[10];
char c;
int j=0;
printf("Enter the variables");
for(int i=0;i<100;i++)
{
c=getchar();
if(c=='\n');
else if(c!=EOF)
{
variable[j]=c;
j++;
}
else
{
variable[j]=-1;
j++;
break;
}
}
char terminal[10];
printf("Enter the terminals");
j=0;
for(int i=0;i<100;i++)
{
c=getchar();
if(c=='\n');
else if(c!=EOF)
{
terminal[i]=c;
j++;
}
else
{
terminal[i]=-1;
j++;
break;
}
}
int i=0;
while(variable[i]!=-1)
{
int j=0;
int k=0;
int lr=0;
int cr=0;
while(j==0)
{
struct production prod;
prod.variable=variable[i];
printf("Enter the production of %c",variable[i]);
scanf("%s",&prod.value[k]);

if(prod.variable!=prod.value[k][0])
{
printf("%c->%s\n",prod.variable,prod.value[k]);
lr=1;
}
printf("Enter 0 to enter another production of %c",variable[i]);
scanf("%d",&j);
if(lr==1)
{
cr++;
}
if(cr!=0)
{
int k=0;
if(prod.variable==prod.value[k][0])
{
printf("%c->%sU'\n",prod.variable,prod.value[k+1]);
printf("U->");
int l=1;
int len=strlen(prod.value[k]);
while(l!=len)
{
printf("%c",prod.value[k][l]);
l++;
}
printf("|e");
}
}
k++;
}
i++;
}
return 0;
}
Write a program in c to implement nfa to dfa .
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_LEN 100
char NFA_FILE[MAX_LEN];
char buffer[MAX_LEN];
int zz = 0;

struct DFA {
char *states;
int count;
} dfa;
int last_index = 0;
FILE *fp; int symbols;
void reset(int ar[], int size) {
int i;
for (i = 0; i < size; i++) {
ar[i] = 0;
}
}
void check(int ar[], char S[]) {
int i, j;
int len = strlen(S);
for (i = 0; i < len; i++) {
j = ((int)(S[i]) - 65);
ar[j]++;
}
}
void state(int ar[], int size, char S[]) {
int j, k = 0;
for (j = 0; j < size; j++) {
if (ar[j] != 0)
S[k++] = (char)(65 + j);
}

// mark the end of the state


S[k] = '\0';
}

// To pick the next closure from closure set


int closure(int ar[], int size) {
int i;

for (i = 0; i < size; i++) {


if (ar[i] == 1)
return i;
} return (100); }
int indexing(struct DFA *dfa) {
int i;
for (i = 0; i < last_index; i++) {
if (dfa[i].count == 0)
return 1;
}
return -1;
}
void Display_closure(int states, int closure_ar[],
char *closure_table[],
char *NFA_TABLE[][symbols + 1],
char *DFA_TABLE[][symbols]) {
int i;
for (i = 0; i < states; i++) {
reset(closure_ar, states);
closure_ar[i] = 2;

if (strcmp(&NFA_TABLE[i][symbols], "-") != 0) {
strcpy(buffer, &NFA_TABLE[i][symbols]);
check(closure_ar, buffer);
int z = closure(closure_ar, states);
while (z != 100)
{
if (strcmp(&NFA_TABLE[z][symbols], "-") != 0) {
strcpy(buffer, &NFA_TABLE[z][symbols]);
check(closure_ar, buffer);
}
closure_ar[z]++;
z = closure(closure_ar, states);
}
}
printf("\n e-Closure (%c) :\t", (char)(65 + i));

bzero((void *)buffer, MAX_LEN);


state(closure_ar, states, buffer);
strcpy(&closure_table[i], buffer);
printf("%s\n", &closure_table[i]);
}}
int new_states(struct DFA *dfa, char S[]) {
int i;
for (i = 0; i < last_index; i++) {
if (strcmp(&dfa[i].states, S) == 0)
return 0;
}
strcpy(&dfa[last_index++].states, S);
dfa[last_index - 1].count = 0;
return 1;
}
void trans(char S[], int M, char *clsr_t[], int st,
char *NFT[][symbols + 1], char TB[]) {
int len = strlen(S);
int i, j, k, g;
int arr[st];
int sz;
reset(arr, st);
char temp[MAX_LEN], temp2[MAX_LEN];
char *buff;
for (i = 0; i < len; i++) {
j = ((int)(S[i] - 65));
strcpy(temp, &NFT[j][M]);

if (strcmp(temp, "-") != 0) {
sz = strlen(temp);
g = 0;

while (g < sz) {


k = ((int)(temp[g] - 65));
strcpy(temp2, &clsr_t[k]);
check(arr, temp2);
g++;
} } }
bzero((void *)temp, MAX_LEN);
state(arr, st, temp);
if (temp[0] != '\0') {
strcpy(TB, temp);
} else
strcpy(TB, "-"); }
printf("\t\t DFA TRANSITION STATE TABLE \t\t \n\n");
printf("\n STATES OF DFA :\t\t");

for (i = 1; i < last_index; i++)


printf("%s, ", &dfa_states[i].states);
printf("\n");
printf("\n GIVEN SYMBOLS FOR DFA: \t");

for (i = 0; i < symbols; i++)


printf("%d, ", i);
printf("\n\n");
printf("STATES\t");

for (i = 0; i < symbols; i++)


printf("|%d\t", i);
printf("\n");
printf("--------+-----------------------\n");
for (i = 0; i < zz; i++) {
printf("%s\t", &dfa_states[i + 1].states);
for (j = 0; j < symbols; j++) {
printf("|%s \t", &DFA_TABLE[i][j]);
} printf("\n");
}}
int main() {
struct DFA *dfa_states = malloc(MAX_LEN * (sizeof(dfa)));
states = 6, symbols = 2;
printf("\n STATES OF NFA :\t\t");
for (i = 0; i < states; i++)
printf("%c, ", (char)(65 + i));
printf("\n");
printf("\n GIVEN SYMBOLS FOR NFA: \t");
for (i = 0; i < symbols; i++)
printf("%d, ", i);
printf("eps");
printf("\n\n");
char *NFA_TABLE[states][symbols + 1];
char *DFA_TABLE[MAX_LEN][symbols];
strcpy(&NFA_TABLE[0][0], "FC");
strcpy(&NFA_TABLE[0][1], "-");
strcpy(&NFA_TABLE[0][2], "BF");
strcpy(&NFA_TABLE[1][0], "-");
strcpy(&NFA_TABLE[1][1], "C");
strcpy(&NFA_TABLE[1][2], "-");
strcpy(&NFA_TABLE[2][0], "-");
strcpy(&NFA_TABLE[2][1], "-");
strcpy(&NFA_TABLE[2][2], "D");
strcpy(&NFA_TABLE[3][0], "E");
printf("\n NFA STATE TRANSITION TABLE \n\n\n");
printf("STATES\t");
for (i = 0; i < symbols; i++)
printf("|%d\t", i);
printf("eps\n");
printf("--------+------------------------------------\n");
for (i = 0; i < states; i++) {
printf("%c\t", (char)(65 + i));
for (j = 0; j <= symbols; j++) {
printf("|%s \t", &NFA_TABLE[i][j]);
}
printf("\n");
}
int closure_ar[states];
char *closure_table[states];
Display_closure(states, closure_ar, closure_table, NFA_TABLE, DFA_TABLE);
strcpy(&dfa_states[last_index++].states, "-");
dfa_states[last_index - 1].count = 1;
bzero((void *)buffer, MAX_LEN);
strcpy(buffer, &closure_table[0]);
strcpy(&dfa_states[last_index++].states, buffer);
int Sm = 1, ind = 1;
int start_index = 1;
while (ind != -1) {
dfa_states[start_index].count = 1;
Sm = 0;
for (i = 0; i < symbols; i++) {
trans(buffer, i, closure_table, states, NFA_TABLE, T_buf);
strcpy(&DFA_TABLE[zz][i], T_buf);
Sm = Sm + new_states(dfa_states, T_buf);
}
ind = indexing(dfa_states);
if (ind != -1)
strcpy(buffer, &dfa_states[++start_index].states);
zz++;
}
Display_DFA(last_index, dfa_states, DFA_TABLE);
return 0; }

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy