Implemented section 1.5 - associating a token to the table entry. Added error messages for overflow integer and floats. Some other minor changes to main.h.

Author: AlexGliesch

include/cc_dict.h

@@ -51,7 +51,7 @@ void free_comp_dict_item_t(comp_dict_item_t* item);
  * */
 comp_dict_item_t* symbols_table_add(
 	const char* key, 
-	int line, 
+	int line_number, 
 	int token_type, 
 	const char* token_value, 
 	comp_dict_t* table);
@@ -74,6 +74,6 @@ void symbols_table_finalize(comp_dict_t* table);
 /* given a text and the token type, computes the value corresponding to that
  * text, puts it in an allocated void*, and returns it. 
  * see comp_dict_item_t::value for more info. */
-void* interpret_token_value(const char* text, int token_type);
+void* interpret_token_value(const char* text, int token_type, int line_number);
 
 #endif

include/cc_misc.h

@@ -2,6 +2,8 @@
 #define __MISC_H
 #include <stdio.h>
 
+struct comp_dict_item_t;
+
 int getLineNumber (void);
 
 void yyerror (char const *mensagem);
@@ -12,7 +14,7 @@ void main_finalize (void);
 
 /* receives a token, and, if it needs to be added to the symbols table, add it.
  * return its token id at the end. */
-int recognize_token(const char* token_text, int token_id);
+int recognize_token(int token_id);
 
 /* given a lexeme and it's type, computes the key that will be used for that
 * lexeme in the symbols table, and returns a pointer to it. note: the string

include/main.h

@@ -26,11 +26,14 @@ extern int yylex(void);
   Constantes a serem utilizadas para diferenciar os lexemas que estão
   registrados na tabela de símbolos.
 */
-#define SIMBOLO_LITERAL_INT    1
-#define SIMBOLO_LITERAL_FLOAT  2
-#define SIMBOLO_LITERAL_CHAR   3
-#define SIMBOLO_LITERAL_STRING 4
-#define SIMBOLO_LITERAL_BOOL   5
-#define SIMBOLO_IDENTIFICADOR  6
+enum { 
+	SIMBOLO_LITERAL_INT = 1,
+	SIMBOLO_LITERAL_FLOAT,
+	SIMBOLO_LITERAL_CHAR,
+	SIMBOLO_LITERAL_STRING,
+	SIMBOLO_LITERAL_BOOL,
+	SIMBOLO_IDENTIFICADOR,
+	SIMBOLO_ERRO
+};
 
 #endif

parser.y

@@ -1,6 +1,8 @@
 
 %{
 #include <stdio.h>
+#include "cc_dict.h" /* we must add this so we can specify comp_dict_item_t 
+					  * in yylval's union */
 %}
 
 /* Declaração dos tokens da linguagem */
@@ -34,6 +36,10 @@
 %token TK_IDENTIFICADOR
 %token TOKEN_ERRO
 
+%union {
+    comp_dict_item_t* valor_simbolo_lexico;
+}
+
 %left TK_OC_OR TK_OC_AND
 %nonassoc TK_OC_LE TK_OC_GE TK_OC_EQ TK_OC_NE '<' '>'
 %left '+' '-'

scanner.l

@@ -2,6 +2,8 @@
 Integrantes: Alex Gliesch, Leonardo Tagliaro, Marina Fortes Rey */
 
 %{
+
+#include "cc_dict.h"
 #include "parser.h" /* arquivo automaticamente gerado pelo bison */
 #include "cc_misc.h" /* for the recognize_token function. */
 int lineCounter = 1;
@@ -32,34 +34,34 @@ specialchar [,|;|:|(|)|\[|\]|{|}|+|\-|*|/|<|>|=|!|&|$]
 <comment>"*"+"/"  BEGIN(INITIAL);
 "//".*			;
 "\n"		;lineCounter++;
-"false"			return recognize_token(yytext, TK_LIT_FALSE);
-"true"			return recognize_token(yytext, TK_LIT_TRUE);
-"int"			return recognize_token(yytext, TK_PR_INT);
-"float"			return recognize_token(yytext, TK_PR_FLOAT);
-"bool"			return recognize_token(yytext, TK_PR_BOOL);
-"char"			return recognize_token(yytext, TK_PR_CHAR);
-"string"		return recognize_token(yytext, TK_PR_STRING);
-"if"			return recognize_token(yytext, TK_PR_IF);
-"then"			return recognize_token(yytext, TK_PR_THEN);
-"else"			return recognize_token(yytext, TK_PR_ELSE);
-"while"			return recognize_token(yytext, TK_PR_WHILE);
-"do"			return recognize_token(yytext, TK_PR_DO);
-"input"			return recognize_token(yytext, TK_PR_INPUT);
-"output"		return recognize_token(yytext, TK_PR_OUTPUT);
-"return"		return recognize_token(yytext, TK_PR_RETURN);
-"const"			return recognize_token(yytext, TK_PR_CONST);
-"static"		return recognize_token(yytext, TK_PR_STATIC);
-"<="			return recognize_token(yytext, TK_OC_LE);
-">="			return recognize_token(yytext, TK_OC_GE);
-"=="			return recognize_token(yytext, TK_OC_EQ);
-"!="			return recognize_token(yytext, TK_OC_NE);
-"&&"			return recognize_token(yytext, TK_OC_AND);
-"||"			return recognize_token(yytext, TK_OC_OR);
-{integer}			return recognize_token(yytext, TK_LIT_INT);
-{floatamount}		return recognize_token(yytext, TK_LIT_FLOAT);
-{char}			return recognize_token(yytext, TK_LIT_CHAR);
-{string}			return recognize_token(yytext, TK_LIT_STRING);
-{specialchar}	return recognize_token(yytext, (int) yytext[0]);
-{identifier}		return recognize_token(yytext, TK_IDENTIFICADOR);
+"false"			return recognize_token(TK_LIT_FALSE);
+"true"			return recognize_token(TK_LIT_TRUE);
+"int"			return recognize_token(TK_PR_INT);
+"float"			return recognize_token(TK_PR_FLOAT);
+"bool"			return recognize_token(TK_PR_BOOL);
+"char"			return recognize_token(TK_PR_CHAR);
+"string"		return recognize_token(TK_PR_STRING);
+"if"			return recognize_token(TK_PR_IF);
+"then"			return recognize_token(TK_PR_THEN);
+"else"			return recognize_token(TK_PR_ELSE);
+"while"			return recognize_token(TK_PR_WHILE);
+"do"			return recognize_token(TK_PR_DO);
+"input"			return recognize_token(TK_PR_INPUT);
+"output"		return recognize_token(TK_PR_OUTPUT);
+"return"		return recognize_token(TK_PR_RETURN);
+"const"			return recognize_token(TK_PR_CONST);
+"static"		return recognize_token(TK_PR_STATIC);
+"<="			return recognize_token(TK_OC_LE);
+">="			return recognize_token(TK_OC_GE);
+"=="			return recognize_token(TK_OC_EQ);
+"!="			return recognize_token(TK_OC_NE);
+"&&"			return recognize_token(TK_OC_AND);
+"||"			return recognize_token(TK_OC_OR);
+{integer}			return recognize_token(TK_LIT_INT);
+{floatamount}		return recognize_token(TK_LIT_FLOAT);
+{char}			return recognize_token(TK_LIT_CHAR);
+{string}			return recognize_token(TK_LIT_STRING);
+{specialchar}	return recognize_token((int) yytext[0]);
+{identifier}		return recognize_token(TK_IDENTIFICADOR);
 .				return TOKEN_ERRO;
 %%

src/cc_dict.c

@@ -19,20 +19,21 @@ void free_comp_dict_item_t(comp_dict_item_t* item) {
 /* The global symbols table defined in the program. */
 comp_dict_t symbols_table = NULL;
 
-comp_dict_item_t* symbols_table_add(const char* key, int line,
+comp_dict_item_t* symbols_table_add(const char* key, int line_number,
 	int token_type, const char* token_value, comp_dict_t* table) {
 
 	comp_dict_item_t* item = symbols_table_find(key, table);
 
 	if (item != NULL) {
 		/* an item with the same key is already in the symbols table.
 		 * we have to update the line where it appeared and the value. */
-		item->line_where_it_last_appeared = line;
+		item->line_where_it_last_appeared = line_number;
 
 		if (item->value != NULL) 
 			free(item->value);
 
-		item->value = interpret_token_value(token_value, token_type);
+		item->value = interpret_token_value(token_value, token_type, 
+			line_number);
 
 		/* note that we don't have to change the token_type or worry about
 		 * the value's type, since, if the token_type were different,
@@ -45,8 +46,8 @@ comp_dict_item_t* symbols_table_add(const char* key, int line,
 
 	item->token = (const char*) malloc((strlen(key) + 1) * sizeof(char));
 	strcpy((char*)item->token, key);	
-	item->line_where_it_last_appeared = line;
-	item->value = interpret_token_value(token_value, token_type);
+	item->line_where_it_last_appeared = line_number;
+	item->value = interpret_token_value(token_value, token_type, line_number);
 	item->token_type = token_type;
 
 	HASH_ADD_KEYPTR(hh, *table, item->token, strlen(item->token), item);
@@ -82,42 +83,50 @@ int symbols_table_count(comp_dict_t* table) {
 	return HASH_COUNT(*table);
 }
 
-void* interpret_token_value(const char* text, int token_type) {
+void* interpret_token_value(const char* text, int token_type, int line_number) {
+	//printf("text %s interpreted as %d -> ", text, token_type);
 	void* value = NULL;
 	if (token_type == SIMBOLO_LITERAL_INT) {
 		value = malloc(sizeof(int));
 		*((int*)value) = strtol(text, NULL, 10);
 		if (errno == ERANGE) {
-			/* int value is off integer limits, defaults to 2^31 - 1. 
-			 * should we print an error message here?*/
+			/* int value is off integer limits, defaults to 2^31 - 1. */
+			printf("warning: line %d: integer value %s is off limits. "
+				"defaulting to %d\n", line_number, text, *((int*)value));
 		}
+		//printf("%d\n", *((int*)value));
 	} else if (token_type == SIMBOLO_LITERAL_CHAR) {
 		value = malloc(sizeof(char));
 		*((char*)value) = text[0];
+		//printf("%c\n", *((char*)value));
 	} else if (token_type == SIMBOLO_LITERAL_BOOL) {
 		value = malloc(sizeof(int));		
 		*((int*)value) = strcmp(text, "false"); /* strcmp returns 0 if strings 
 										are equal, and different than 0 
 										otherwise. so, if it's false, we'll get 
 										0 anyway :) */
+		//printf("%d\n", *((int*)value));
 	} else if (token_type == SIMBOLO_LITERAL_FLOAT) {
 		value = malloc(sizeof(float));
 		*((float*)value) = strtof(text, NULL);
 		if (errno == ERANGE) {
-			/* float value overflow. should we print an error message? */
+			/* float value overflow. */
+			printf("warning: line %d: float value %s is off limits. "
+				"defaulting to %.2f\n", line_number, text, *((float*)value));
 		}
+		//printf("%f\n", *((float*)value));
 	} else if (token_type == SIMBOLO_LITERAL_STRING) {
 		value = malloc((strlen(text) + 1) * sizeof(char));
 		strcpy(value, text);
+		//printf("%s\n", (char*)value);
 	} else if (token_type == SIMBOLO_IDENTIFICADOR) {
 		/* if the token is an identifier, it has no value associated to it
 		 * for now. */
 		value = NULL;
 	} else {
 		/* error. */
-		printf("invalid token type (%d) passed to interpret_token_value().\n", 
+		printf("invalid token type (%d) passed to interpret_token_value().\n",
 			token_type);
-		//assert(0);
 		value = NULL;
 	}
 	return value;

src/cc_misc.c

@@ -10,6 +10,9 @@ extern int lineCounter; /* lineCounter is declared in scanner.c,
 extern comp_dict_t symbols_table; /* the compiler's symbols table, declared
 								  in cc_dict.c */
 
+extern YYSTYPE yylval;
+extern char* yytext;
+
 int getLineNumber(void) {
 	return lineCounter;
 }
@@ -27,7 +30,9 @@ void main_finalize(void) {
 	symbols_table_finalize(&symbols_table);
 }
 
-int recognize_token(const char* token_text, int token_id) {
+int recognize_token(int token_id) {
+	const char* token_text = yytext;
+	yylval.valor_simbolo_lexico = NULL;
 
 	/* add the lexeme to symbols table only if it is a literal or an
 	 * identificator. */
@@ -62,20 +67,30 @@ int recognize_token(const char* token_text, int token_id) {
 		default:
 			printf("Invalid token id (%d) given to "
 				"compute_symbols_table_key()!\n", token_id);
-			//assert(0);
+		}
+
+		/* remove double and single quotes if token is a string or
+		* char literal */
+		if (token_type_id == SIMBOLO_LITERAL_STRING ||
+			token_type_id == SIMBOLO_LITERAL_CHAR) {
+			token_text = remove_quotes(token_text);
 		}
 
 		/* get the key that refers to that lexeme: */
 		char* symbols_table_key = compute_symbols_table_key(token_text, 
 			token_type_id);
 
 		/* add the lexeme to the symbols table. */
-		symbols_table_add(symbols_table_key, /* key */
-						  getLineNumber(), /* line number */
-						  token_type_id, /* type of token */
-						  token_text, /* token value*/
-						  &symbols_table);
+		yylval.valor_simbolo_lexico = symbols_table_add(symbols_table_key, 
+			getLineNumber(), token_type_id, token_text, &symbols_table);
+
 		free((void*)symbols_table_key);
+
+		/* deallocate token_text here, because we created a new string when we
+		* removed quotes.*/
+		if (token_type_id == SIMBOLO_LITERAL_STRING ||
+			token_type_id == SIMBOLO_LITERAL_CHAR)
+			free((void*)token_text);
 	}
 
 	/* then, return the token's identifier. */
@@ -91,13 +106,6 @@ char* remove_quotes(const char* token_text) {
 }
 
 char* compute_symbols_table_key(const char* token_text, int token_type_id) {
-	/* remove double and single quotes if token is a string or
-	* char literal */
-	if (token_type_id == SIMBOLO_LITERAL_STRING || 
-		token_type_id == SIMBOLO_LITERAL_CHAR) {
-		//assert(token_text[0] == '"' || token_text[0] == '\'');
-		token_text = remove_quotes(token_text);
-	}
 
 	/* here, we safely assume that the token_type_id's number will never 
 	 * have more more than 20 characters, which is the maximum length of 
@@ -109,11 +117,5 @@ char* compute_symbols_table_key(const char* token_text, int token_type_id) {
 	 * an identifier ('$$') so no conflicts arise */
 	sprintf(symbols_table_key, "%d $$ %s", token_type_id, token_text);
 
-	/* deallocate token_text here, because we created a new string when we 
-	 * removed quotes.*/
-	if (token_type_id == SIMBOLO_LITERAL_STRING || 
-		token_type_id == SIMBOLO_LITERAL_CHAR)
-		free((void*)token_text);
-
 	return symbols_table_key;
 }