X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=lexer.c;h=779f4b326cdd99ad3f11b30910241072d940852a;hb=ba0d46aeb8456932335728047230840ef65fdcf4;hp=f1b00e368942380411244d9d8822d65a4fe213cc;hpb=79e35de99b8c98654757dcbf42070ab8e53bd856;p=cparser

diff --git a/lexer.c b/lexer.c
index f1b00e3..779f4b3 100644
--- a/lexer.c
+++ b/lexer.c
@@ -65,7 +65,7 @@ bool               allow_dollar_in_symbol = true;
  */
 static void parse_error(const char *msg)
 {
-	errorf(&lexer_token.source_position,  "%s", msg);
+	errorf(&lexer_token.source_position, "%s", msg);
 }
 
 /**
@@ -75,7 +75,7 @@ static void parse_error(const char *msg)
  */
 static NORETURN internal_error(const char *msg)
 {
-	internal_errorf(&lexer_token.source_position,  "%s", msg);
+	internal_errorf(&lexer_token.source_position, "%s", msg);
 }
 
 static inline void next_real_char(void)
@@ -304,60 +304,78 @@ end_symbol:
 
 static void parse_integer_suffix(bool is_oct_hex)
 {
-	bool is_unsigned  = false;
-	bool min_long     = false;
-	bool min_longlong = false;
-
-	if(c == 'U' || c == 'u') {
-		is_unsigned = true;
+	bool is_unsigned     = false;
+	bool min_long        = false;
+	bool min_longlong    = false;
+	bool not_traditional = false;
+	int  pos             = 0;
+	char suffix[4];
+
+	if (c == 'U' || c == 'u') {
+		not_traditional = true;
+		suffix[pos++]   = toupper(c);
+		is_unsigned     = true;
 		next_char();
-		if(c == 'L' || c == 'l') {
+		if (c == 'L' || c == 'l') {
+			suffix[pos++] = toupper(c);
 			min_long = true;
 			next_char();
-			if(c == 'L' || c == 'l') {
+			if (c == 'L' || c == 'l') {
+				suffix[pos++] = toupper(c);
 				min_longlong = true;
 				next_char();
 			}
 		}
-	} else if(c == 'l' || c == 'L') {
+	} else if (c == 'l' || c == 'L') {
+		suffix[pos++] = toupper(c);
 		min_long = true;
 		next_char();
-		if(c == 'l' || c == 'L') {
-			min_longlong = true;
+		if (c == 'l' || c == 'L') {
+			not_traditional = true;
+			suffix[pos++]   = toupper(c);
+			min_longlong    = true;
 			next_char();
-			if(c == 'u' || c == 'U') {
-				is_unsigned = true;
+			if (c == 'u' || c == 'U') {
+				suffix[pos++] = toupper(c);
+				is_unsigned   = true;
 				next_char();
 			}
-		} else if(c == 'u' || c == 'U') {
-			is_unsigned = true;
+		} else if (c == 'u' || c == 'U') {
+			not_traditional = true;
+			suffix[pos++]   = toupper(c);
+			is_unsigned     = true;
 			next_char();
 			lexer_token.datatype = type_unsigned_long;
 		}
 	}
 
-	if(!is_unsigned) {
+	if (warning.traditional && not_traditional) {
+		suffix[pos] = '\0';
+		warningf(&lexer_token.source_position,
+			"traditional C rejects the '%s' suffix", suffix);
+	}
+	if (!is_unsigned) {
 		long long v = lexer_token.v.intvalue;
-		if(!min_long) {
-			if(v >= TARGET_INT_MIN && v <= TARGET_INT_MAX) {
+		if (!min_long) {
+			if (v >= TARGET_INT_MIN && v <= TARGET_INT_MAX) {
 				lexer_token.datatype = type_int;
 				return;
-			} else if(is_oct_hex && v >= 0 && v <= TARGET_UINT_MAX) {
+			} else if (is_oct_hex && v >= 0 && v <= TARGET_UINT_MAX) {
 				lexer_token.datatype = type_unsigned_int;
 				return;
 			}
 		}
-		if(!min_longlong) {
-			if(v >= TARGET_LONG_MIN && v <= TARGET_LONG_MAX) {
+		if (!min_longlong) {
+			if (v >= TARGET_LONG_MIN && v <= TARGET_LONG_MAX) {
 				lexer_token.datatype = type_long;
 				return;
-			} else if(is_oct_hex && v >= 0 && (unsigned long long)v <= (unsigned long long)TARGET_ULONG_MAX) {
+			} else if (is_oct_hex && v >= 0 && (unsigned long long)v <= (unsigned long long)TARGET_ULONG_MAX) {
 				lexer_token.datatype = type_unsigned_long;
 				return;
 			}
 		}
 		unsigned long long uv = (unsigned long long) v;
-		if(is_oct_hex && uv > (unsigned long long) TARGET_LONGLONG_MAX) {
+		if (is_oct_hex && uv > (unsigned long long) TARGET_LONGLONG_MAX) {
 			lexer_token.datatype = type_unsigned_long_long;
 			return;
 		}
@@ -365,11 +383,11 @@ static void parse_integer_suffix(bool is_oct_hex)
 		lexer_token.datatype = type_long_long;
 	} else {
 		unsigned long long v = (unsigned long long) lexer_token.v.intvalue;
-		if(!min_long && v <= TARGET_UINT_MAX) {
+		if (!min_long && v <= TARGET_UINT_MAX) {
 			lexer_token.datatype = type_unsigned_int;
 			return;
 		}
-		if(!min_longlong && v <= TARGET_ULONG_MAX) {
+		if (!min_longlong && v <= TARGET_ULONG_MAX) {
 			lexer_token.datatype = type_unsigned_long;
 			return;
 		}
@@ -383,11 +401,19 @@ static void parse_floating_suffix(void)
 	/* TODO: do something useful with the suffixes... */
 	case 'f':
 	case 'F':
+		if (warning.traditional) {
+			warningf(&lexer_token.source_position,
+				"traditional C rejects the 'F' suffix");
+		}
 		next_char();
 		lexer_token.datatype = type_float;
 		break;
 	case 'l':
 	case 'L':
+		if (warning.traditional) {
+			warningf(&lexer_token.source_position,
+				"traditional C rejects the 'F' suffix");
+		}
 		next_char();
 		lexer_token.datatype = type_long_double;
 		break;
@@ -487,34 +513,74 @@ end:
  */
 static void parse_number_hex(void)
 {
+	bool is_float = false;
 	assert(c == 'x' || c == 'X');
 	next_char();
 
+	obstack_1grow(&symbol_obstack, '0');
+	obstack_1grow(&symbol_obstack, 'x');
+
 	while(isxdigit(c)) {
 		obstack_1grow(&symbol_obstack, (char) c);
 		next_char();
 	}
-	obstack_1grow(&symbol_obstack, '\0');
-	char *string = obstack_finish(&symbol_obstack);
 
-	if(c == '.' || c == 'p' || c == 'P') {
+	if (c == '.') {
+		obstack_1grow(&symbol_obstack, (char) c);
+		next_char();
+
+		while (isxdigit(c)) {
+			obstack_1grow(&symbol_obstack, (char) c);
+			next_char();
+		}
+		is_float = true;
+	}
+	if (c == 'p' || c == 'P') {
+		obstack_1grow(&symbol_obstack, (char) c);
 		next_char();
-		internal_error("Hex floating point numbers not implemented yet");
+
+		if (c == '-' || c == '+') {
+			obstack_1grow(&symbol_obstack, (char) c);
+			next_char();
+		}
+
+		while (isxdigit(c)) {
+			obstack_1grow(&symbol_obstack, (char) c);
+			next_char();
+		}
+		is_float = true;
 	}
+
+	obstack_1grow(&symbol_obstack, '\0');
+	char *string = obstack_finish(&symbol_obstack);
 	if(*string == '\0') {
 		parse_error("invalid hex number");
 		lexer_token.type = T_ERROR;
+		obstack_free(&symbol_obstack, string);
+		return;
 	}
 
-	const char *endptr;
-	lexer_token.type       = T_INTEGER;
-	lexer_token.v.intvalue = parse_int_string(string, &endptr, 16);
-	if(*endptr != '\0') {
-		parse_error("hex number literal too long");
+	if (is_float) {
+		char *endptr;
+		lexer_token.type         = T_FLOATINGPOINT;
+		lexer_token.v.floatvalue = strtold(string, &endptr);
+
+		if(*endptr != '\0') {
+			parse_error("invalid hex float literal");
+		}
+
+		parse_floating_suffix();
+	} else {
+		const char *endptr;
+		lexer_token.type       = T_INTEGER;
+		lexer_token.v.intvalue = parse_int_string(string + 2, &endptr, 16);
+		if(*endptr != '\0') {
+			parse_error("hex number literal too long");
+		}
+		parse_integer_suffix(true);
 	}
 
 	obstack_free(&symbol_obstack, string);
-	parse_integer_suffix(true);
 }
 
 /**
@@ -569,23 +635,23 @@ static void parse_number_oct(void)
 static void parse_number_dec(void)
 {
 	bool is_float = false;
-	while(isdigit(c)) {
+	while (isdigit(c)) {
 		obstack_1grow(&symbol_obstack, (char) c);
 		next_char();
 	}
 
-	if(c == '.') {
+	if (c == '.') {
 		obstack_1grow(&symbol_obstack, '.');
 		next_char();
 
-		while(isdigit(c)) {
+		while (isdigit(c)) {
 			obstack_1grow(&symbol_obstack, (char) c);
 			next_char();
 		}
 		is_float = true;
 	}
 	if(c == 'e' || c == 'E') {
-		obstack_1grow(&symbol_obstack, 'e');
+		obstack_1grow(&symbol_obstack, (char) c);
 		next_char();
 
 		if(c == '-' || c == '+') {
@@ -800,6 +866,10 @@ string_t concat_strings(const string_t *const s1, const string_t *const s2)
 	memcpy(concat, s1->begin, len1);
 	memcpy(concat + len1, s2->begin, len2 + 1);
 
+	if (warning.traditional) {
+		warningf(&lexer_token.source_position,
+			"traditional C rejects string constant concatenation");
+	}
 #if 0 /* TODO hash */
 	const char *result = strset_insert(&stringset, concat);
 	if(result != concat) {
@@ -826,6 +896,10 @@ wide_string_t concat_string_wide_string(const string_t *const s1, const wide_str
 		concat[i] = src[i];
 	}
 	memcpy(concat + len1, s2->begin, (len2 + 1) * sizeof(*concat));
+	if (warning.traditional) {
+		warningf(&lexer_token.source_position,
+			"traditional C rejects string constant concatenation");
+	}
 
 	return (wide_string_t){ concat, len1 + len2 + 1 };
 }
@@ -841,6 +915,10 @@ wide_string_t concat_wide_strings(const wide_string_t *const s1, const wide_stri
 	wchar_rep_t *const concat = obstack_alloc(&symbol_obstack, (len1 + len2 + 1) * sizeof(*concat));
 	memcpy(concat,        s1->begin, len1       * sizeof(*concat));
 	memcpy(concat + len1, s2->begin, (len2 + 1) * sizeof(*concat));
+	if (warning.traditional) {
+		warningf(&lexer_token.source_position,
+			"traditional C rejects string constant concatenation");
+	}
 
 	return (wide_string_t){ concat, len1 + len2 + 1 };
 }
@@ -859,6 +937,10 @@ wide_string_t concat_wide_string_string(const wide_string_t *const s1, const str
 	for (size_t i = 0; i != len2 + 1; ++i) {
 		concat[i] = src[i];
 	}
+	if (warning.traditional) {
+		warningf(&lexer_token.source_position,
+			"traditional C rejects string constant concatenation");
+	}
 
 	return (wide_string_t){ concat, len1 + len2 + 1 };
 }
@@ -1110,7 +1192,10 @@ static void skip_multiline_comment(void)
 		case '/':
 			next_char();
 			if (c == '*') {
-				/* TODO: nested comment, warn here */
+				/* nested comment, warn here */
+				if (warning.comment) {
+					warningf(&lexer_token.source_position, "'/*' within comment");
+				}
 			}
 			break;
 		case '*':
@@ -1152,6 +1237,15 @@ static void skip_line_comment(void)
 		case '\r':
 			return;
 
+		case '\\':
+			next_char();
+			if (c == '\n' || c == '\r') {
+				if (warning.comment)
+					warningf(&lexer_token.source_position, "multi-line comment");
+				return;
+			}
+			break;
+
 		default:
 			next_char();
 			break;