/* Programmer: Austin Guthals */
/* A recursive decent parser that checks static semantics */
/* The language is called "tiny"  */

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

/* Some Constants */
#define DELIMETER 1
#define DELIMETER2 6
#define VARIABLE 2
#define NUMBER 3
#define REAL 4
#define INT 5
#define END "end"
#define REAL1 "real"
#define READ1 "Read"
#define DEC "dec"
#define WRITE1 "Write"
#define INT1 "int"
#define PROG "program"
/* Some global variables */
int declaration = 0;
int done = 0;

int dec_counter = 0;
int statement_counter = 0;
int lexical_flag = 0;
char tok_delim[80];
int actual_type;
int type_list[150];
int type_var_counter = 0;
char var_list[150][20];  // Max # of variables is 150
int tok_type;
char token[80];
FILE * file_input;
FILE * file_output;

/* Some local subroutines */
static void get_token(void);
static void isdelim(char c);
static void isdelim2(char *c);
static void isdec(char *temp);
static void dec_part(void);
static void list_var(void);
static void type1(void);
static void isvar(char *temp);
static void isdec(char *temp);
static void statmt_part(void);
static void statement(void);
static void input(void);
static void output(void);
static void assignment(void);
static void expression(void);
static void term(void);
static void factor(void);
static void name_digit(void);
static void identifier(void);
static void serror(char *temp);


/*
  There is a function for just about every production rule
  in the tiny language
*/



static void serror(char *temp) {
  fputs(" Invalid Program ", file_output);
  fputs(temp, file_output);
  exit(0);              // exit program when error found
}

static void prgrm(void) {
	char *c = "prgrm";
	get_token();
       	if(!strncmp("program", token, 7)) {
       		get_token();
       		if(!done)
		  dec_part();
	       	else
		  serror(c);
		if(!done)
		  statmt_part();
	       	else
		  serror(c);
		return;
	       
	}
       	else {
       		serror(c);
       	}
     
	if((!strncmp("end", token, 7)) && (getc(file_input) == EOF))
		return;
	else
	  serror(c); // end was expected
}
static void statmt_part(void) {
        char* c = "statmt_part";
    	statement();
	

	if(!done) {
	  while(token[0] == '!') {
		get_token();
		if(!done)
		  statement();
		else
		  serror(c);
	  }
	}
	else
	  serror(c);
	return;
}
static void statement(void) {     // either Read Write or Assignment
	if(!strncmp(token, READ1, 7))
		input();
	else if(!strncmp(token, WRITE1, 7)) 
		output();
	else
		assignment();

	return;
}
static void input(void) {
	char *c = "input";
	get_token();
	if(!done) {

	  if(token[0] == '(') {
	        get_token();
		if(done)
		  serror(c);
	        list_var();
		if(token[0] == ')') {
			get_token();
			if(done)
			  serror(c);
		}
		else
			serror(c);
	  }
	  else
		serror(c);
	}
	else
	  serror(c);
       return;
}
static void output(void) {
        char* c = "output";
	get_token();
	if(done)
	  serror(c);
	list_var();
	return;
}
static void assignment(void) {
  char *c = "assignment";
  int test1 = 0;
  int expected_type = 0;
  int x;
  int i;
  actual_type = 0;
  // printf(" assignment var = %s tok_type = %d\n", token, tok_type);
  if(tok_type == VARIABLE) {
    for(i=0; i<type_var_counter; i++) {
      if(!strncmp(token, var_list[i], 20)) {  // largest variable 20 charecters
	x = i;
	test1 = 1;
	break;
      }
    }
    if(!test1) 
      serror(c);   // unknown variable
    expected_type = type_list[x];
    
    get_token();
    if(done)
      serror(c);
    if(token[0] == '=') {
      get_token();
      expression();
    }
    else
      serror(c);
    
    if(actual_type != expected_type)   
      serror(c);      // different_types
  }
  else
    serror(c);
  actual_type = 0;
  return;
}
static void expression(void) {
  char* c = "expression";
  term();
  while((token[0] == '+') || (token[0] == '-')) {
    get_token();
    if(done)
      serror(c);
    term();
  }
  return;
}
static void term(void) {
  char* c = "term";
  factor();
  while((token[0] == '*') || (token[0] == '/')) {
    get_token();
    if(done)
      serror(c);
    factor();
  }
  return;
}
static void factor(void) {     // token should be Variable, number
        int x;                //   or ( expression )
	int test = 0;        //  sets actual_type for checking
        int i;
	char *c = "factor";
	if(token[0] == '(') {
		get_token();
		expression();
		get_token();
		if(token[0] == ')') {
		  get_token();
		  return;
		}
		else
			serror(c);
	}
	else if(tok_type == VARIABLE) {
	    for(i=0; i<type_var_counter; i++) {
	      if(!strncmp(token, var_list[i], 20)) {
	       x = i;
	       test = 1;
	       break;
	      }
	    } 
    	    actual_type = type_list[x];
	    if(!test)
	      serror(c);   // unknown variable
	    
	    get_token();
	    return;
	}
	
	
	else if((tok_type == REAL) || (actual_type == REAL)) {
  	        get_token();
	        actual_type = REAL;
		return;
	}
	else if(tok_type == INT) {
	        get_token();
	        actual_type = INT;
		return;
	}
	else {
		serror(c);
	       get_token();
 	       return;
	}
}

static void dec_part(void) {   // first dec is normal
  char *c = "dec_part"; // all others have ?
	char *t = "dec";
	if(!dec_counter) {
		if(!strncmp(t, token, 7)) {
			get_token();
			if(tok_type == VARIABLE) 
		     	     list_var();
			else
			  serror(c);
			if(token[0] == ':')     {
				get_token();
				type1();
				get_token(); // watch this one

			}
			else
			  serror(c);
		}
		else
		  serror(c);
	}
	dec_counter++;
	if(token[0] != '?')
	  serror(c);
	while(token[0] == '?') {
	        get_token();
		if(!strncmp(t, token, 7)) {
			get_token();
			if(tok_type == VARIABLE)
			  list_var();
			else
			  serror(c);
			if(token[0] == ':')     {
				get_token();
				type1();
				get_token();  // get next token
			}
			else
			  serror(c);
		}
		else
		  serror(c);
	}
			
	declaration = 1;
	return;
}
static void list_var(void) { // never have to call
        int i = type_var_counter;
	char *c = "list_var";
	if(!declaration) {  // lexical after list_var
	    if(tok_type == VARIABLE) {
	        strcpy(var_list[i], token);
	       	get_token();    // sets symbol table
	    }
	    else
       		serror(c);
	  
	    while(token[0] == ',') { // gets rid of ,'s
	        get_token();
		if(tok_type == VARIABLE) {
                        i++;
            		strcpy(var_list[i], token);
			get_token();
		}
		else
			serror(c);
	  
	  }
	}
	else { 
		if(tok_type == VARIABLE) 
			get_token();
		else
			serror(c);
	     
 	      while(token[0] == ',') {
		get_token();
		if(tok_type == VARIABLE) {
			get_token();
		}
		else
			serror(c);
	  
	  }
	}
	return;
}	

static void type1(void) {         // gets type of token
  char *c = "type1";
  int t;
  int i;
  int x;
  for(x=0;x<150; x++) {
    if(var_list[x][0] == '\0') {
      i = x;
      break;
    }
  }
  i = i - 1;
  if(!strncmp(REAL1, token, 7)) {
    if(i == type_var_counter)
        type_list[type_var_counter] = REAL;
    else {
      for(t=type_var_counter; t<=i; i++)
	type_list[t] = REAL;
    }

  }
  else if(!strncmp(INT1, token, 7)) {
     if(i == type_var_counter)
        type_list[type_var_counter] = INT;  
    else {
      for(t=type_var_counter; t<=i; t++) // multiple vars can be declared
	type_list[t] = INT;        // at once
    }
  }
  else
   serror(c);
  
  type_var_counter = i + 1;

  return;
}

void main(int argc, char *argv[])  {
	
	
	if(argc <= 2) {
		printf("you need to enter some command line arguments\n");
		exit(1);
	}

	done = 0;
	file_input = fopen(argv[1], "r");
	file_output = fopen(argv[2], "w");
	prgrm();            // parser is started
	fputs("Valid Program", file_output);
	fclose(file_input);
	fclose(file_output);
}
static void isdelim(char c) {
	tok_type = 0;
	if(strchr("=+-*/():!?,", c)) 
		tok_type = DELIMETER;
	return;
}
static void isdelim2(char *c) {
	const char* s[7];
	char temp[20];
	char r[20];
	int i;
	int a;
	int x;
	int y;
	int cr = 0;
	s[0] = END;
	s[1] = REAL1;
	s[2] = READ1;
	s[3] = DEC;
	s[4] = WRITE1;
	s[5] = INT1;
	s[6] = PROG;
	for(i=0; i<20; i++)
	  r[i] = 0;      // clear out array
	strcpy(temp, c);
       
	x = strlen(c);
	y = x - 3;
        for(i=y; i<x; i++) {
	  r[cr] = temp[i];
	  cr++;
        }
	r[cr] = 0;  // last char must be zero
        if(!strncmp(r, END, 10)) {  // end delim is special case
	      tok_type = DELIMETER2;
	      lexical_flag = 1;        // two tokens in one try
	      strcpy(tok_delim, END);
	      for(a=0; a<y; a++) {
	        token[a] = temp[a];
	      }
	      token[a] = '@';  // isdec removes last char so I add one
	      isdec(token);
	      if((tok_type != INT) && (tok_type != REAL)) { 
		isvar(token);  // make sure token is not decimal
	      }
	}
	else {

 	  for(i=0; i<7; i++) {
		if(!strncmp(s[i], c, 10)) {
			tok_type = DELIMETER2;
			strcpy(token, s[i]);
		}
	  }
	  
	}
	return;
}
static void get_token(void) {      // returns one token at a time
    char temp[60];
    int i;
    int counter = 0;
    for(i = 0;i<60; i++) {     // clear out array
      temp[i] = 0;
    }
    tok_type = 0;
    for(i=0; i<80; i++)     // clear out array
      token[i] = 0;       
	
    if(lexical_flag) {       // might already have desired token
      strcpy(token, tok_delim);
      lexical_flag = 0;
      for(i=0; i<80; i++)
	tok_delim[i] = 0;
      // printf(" token = %s\n", token);
      return;
    }
    else {
        fread(&temp[0], 1, 1, file_input);

	while(isspace(temp[0])) 
	  fread(&temp[0], 1, 1, file_input);

	//printf(" char = %c ", temp[0]);
	if(temp[0] == EOF) {
	  done = 1;
	  return;
       	}
	isdelim(temp[0]); // single char might be delim
	while((((tok_type != REAL) && (tok_type != INT))  && ((tok_type != DELIMETER) && (tok_type != DELIMETER2))) && (tok_type != VARIABLE)) {
  	        counter++;
	       
		fread(&temp[counter], 1, 1, file_input);
	
		while(isspace(temp[counter])) 
		  fread(&temp[counter], 1, 1, file_input);
		//printf(" char = %c ", temp[counter]);
		if(temp[counter] == EOF) {
		  done = 1;
		  return;
	       	}
		isdelim(temp[counter]);
		isdelim2(temp);
				
	}
	if(!counter) {        // token is a single char delim
	  token[0] = temp[counter];
	}
	else {
	  if(tok_type == DELIMETER) {   // token is a num or var with single
	    tok_delim[0] = temp[counter];  // char delimeter at end
	    isdec(temp);
	    lexical_flag = 1;
	    if((tok_type != INT) && (tok_type != REAL)) 
	           isvar(temp);   
	  
	  }
	}

	//printf(" token = %s\n", token);
	return;
    }
}

static void isdec(char *temp) {  // sets value of tok_type
  int count_digits;
  int test3 = 0;
  int test  = 0;
  int test2 = 0;
  int i;
  char temp2[80];
  char temp3[80];
  strcpy(temp2, temp);
  count_digits = strlen(temp2) - 1;  // don't want the delim on the end
  for(i = 0; i<count_digits; i++) {
    if(isdigit(temp2[i])) {
      temp3[i] = temp2[i];
      test = 1;
    }
    else if(temp2[i] == '.') {
      temp3[i] = temp2[i];
      test2 = 2;  // Used as a flag
    }
    else
      test3 = 1;
  }
  token[count_digits] = 0;
  if((test2 == 2) && (test3 != 1)) {
    tok_type = REAL;
    strcpy(token, temp3);
  }
  else if((test == 1) && (test3 != 1)) {
    tok_type = INT;
    strcpy(token, temp3);
  }
  return;
}
static void isvar(char *temp) {  // sets value of tok_type
  int count_length;
  char temp2[80];
  char *c = "isvar";
  int test = 0;
  int test2 = 0;
  int test3 = 0;
  int i;
  strcpy(temp2, temp);
  count_length = strlen(temp2) - 1;
  if(isalpha(temp2[0])) {       // first char must be from alphabet
    token[0] = temp2[0];
    test = 1;
  }
  for(i=1; i<count_length; i++) {
    if((isalpha(temp2[i])) || (isdigit(temp2[i]))) {  // all other
      test2 = 1;                           // chars can be alphanumeric
      token[i] = temp2[i];
    }
      else
	serror(c);     // was not valid variable
  }
  token[count_length] = 0; // give null to last char in string
  if(test) {              // Variable is valid
    tok_type = VARIABLE;
    return;
  }
  else
    serror(c);

}