parser.c

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

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>

/* Global declarations */
/* Variables */
int charClass;
char lexeme [100];
char nextChar;
int lexLen;
int token;
int nextToken;
FILE *in_fp, *fopen();


/* Variables required to handle multiple lines*/
char * line = NULL;
int lineIndex;
char errChar;

/* Function declarations */
void addChar();
void getChar();
void getNonBlank();
int lex();
void expr();
void term();
void factor();
void error();

/* 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 */
int main(int argc, char* argv[]) {
	ssize_t readTest;
	size_t length = 0;

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

	/* File name not provided or illegal characters*/

	if(argc != 2){
		printf("Invalid command");
		exit(0);
	}

	if ((in_fp = fopen(argv[1], "r")) == NULL)
		printf("ERROR - cannot open front.in \n");
	else {
		readTest = getline(&line, &length, in_fp);
		while(readTest != -1){
			lineIndex = 0;
			getChar();
			if(line != NULL){
				do {
					lex();
					expr();
				}while (nextToken != EOF);
			}
			readTest = getline(&line, &length, in_fp);		
		}
	}
	return 0;
}

/*****************************************************/
/* lookup - a function to lookup operators and parentheses
and return the token */
int lookup(char ch) {
	switch (ch) {
		case '(':
			addChar();
			nextToken = LEFT_PAREN;
			break;
		case ')':
			addChar();
			nextToken = RIGHT_PAREN;
			break;
		case '+':
			addChar();
			nextToken = ADD_OP;
			break;
		case '-':
			addChar();
			nextToken = SUB_OP;
			break;
		case '*':
			addChar();
			nextToken = MULT_OP;
			break;
		case '/':
			addChar();
			nextToken = DIV_OP;
			break;

		default:
			addChar();
			nextToken = EOF;
			break;
	}
	return nextToken;
}

/*****************************************************/
/* addChar - a function to add nextChar to lexeme */
void addChar() {
	if (lexLen <= 98) {
		lexeme[lexLen++] = nextChar;
		lexeme[lexLen] = 0;
	}
	else
		printf("Error - lexeme is too long \n");
}

/*****************************************************/
/* getChar - a function to get the next character of
input and determine its character class */
void getChar() {
	if (line[lineIndex] != '\n' && line[lineIndex] != '\0') {
		nextChar = line[lineIndex ++];
		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-whitespacecharacter */
void getNonBlank() {
	while (isspace(nextChar))
		getChar();
}

/*****************************************************/
/* lex - a simple lexical analyzer for arithmetic
expressions */
int lex() {
	lexLen = 0;
	getNonBlank();
	errChar = nextChar;
	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] = 'E';
			lexeme[1] = 'O';
			lexeme[2] = 'F';
			lexeme[3] = 0;
			break;
	} /* End of switch */
	printf("Next token is: %d, Next lexeme is %s\n", nextToken, lexeme);
	return nextToken;
} /* End of function lex */

/* expr
	Parses strings in the language generated by the rule:
	<expr> -> <term> {(+ | -) <term>}
*/
void expr() {
	printf("Enter <expr>\n");
/* Parse the first term */
	term();
/* As long as the next token is + or -, get
the next token and parse the next term */
	while (nextToken == ADD_OP || nextToken == SUB_OP) {
		lex();
		term();
	}
	printf("Exit <expr>\n");
} /* End of function expr */

/* term
	Parses strings in the language generated by the rule:
	<term> -> <factor> {(* | /) <factor>)
*/
void term() {
	printf("Enter <term>\n");
/* Parse the first factor */
	factor();
/* As long as the next token is * or /, get the
	next token and parse the next factor */
	while (nextToken == MULT_OP || nextToken == DIV_OP) {
		lex();
		factor();
	}
	printf("Exit <term>\n");
} /* End of function term */

/* factor
	Parses strings in the language generated by the rule:
	<factor> -> id | int_constant | ( <expr )
*/
void factor() {
	printf("Enter <factor>\n");
/* Determine which RHS */
	if (nextToken == IDENT || nextToken == INT_LIT)
/* Get the next token */
		lex();
/* If the RHS is ( <expr>), call lex to pass over the
	left parenthesis, call expr, and check for the right
	parenthesis */
	else {
		if (nextToken == LEFT_PAREN) {
			lex();
			expr();
			if (nextToken == RIGHT_PAREN)
				lex();
			else
				error();
		} /* End of if (nextToken == ... */

/* It was not an id, an integer literal, or a left
	parenthesis */
	else
		error();
	} /* End of else */

printf("Exit <factor>\n");;
} /* End of function factor */

void error(){
	printf("%s\n", line);
	printf("Error! occurs at %c\n", errChar);
}