X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=parser.c;h=df444bd0c3c9588696a222302d45fd2713935070;hb=5c1f4f4c1fb16d5c4d6de6f8e12b520e2a7f265e;hp=3784034e33141f73a4224d5b55bdf66eb39f4572;hpb=5c804a26fbf22e58afedba1551d31f63d81d4d84;p=cparser

diff --git a/parser.c b/parser.c
index 3784034..df444bd 100644
--- a/parser.c
+++ b/parser.c
@@ -53,7 +53,8 @@ struct declaration_specifiers_t {
 	source_position_t  source_position;
 	unsigned char      declared_storage_class;
 	unsigned char      alignment;         /**< Alignment, 0 if not set. */
-	bool               is_inline;
+	unsigned int       is_inline : 1;
+	unsigned int       deprecated : 1;
 	decl_modifiers_t   decl_modifiers;    /**< MS __declspec extended modifier mask */
 	const char        *deprecated_string; /**< can be set if declaration was marked deprecated. */
 	symbol_t          *get_property_sym;  /**< the name of the get property if set. */
@@ -145,7 +146,7 @@ static void semantic_comparison(binary_expression_t *expression);
 	case T_restrict:        \
 	case T_volatile:        \
 	case T_inline:          \
-	case T_forceinline:
+	case T__forceinline:
 
 #ifdef PROVIDE_COMPLEX
 #define COMPLEX_SPECIFIERS  \
@@ -173,6 +174,7 @@ static void semantic_comparison(binary_expression_t *expression);
 	case T_enum:              \
 	case T___typeof__:        \
 	case T___builtin_va_list: \
+	case T__declspec:         \
 	COMPLEX_SPECIFIERS        \
 	IMAGINARY_SPECIFIERS
 
@@ -282,7 +284,7 @@ static size_t get_expression_struct_size(expression_kind_t kind)
 		[EXPR_CHARACTER_CONSTANT]      = sizeof(const_expression_t),
 		[EXPR_WIDE_CHARACTER_CONSTANT] = sizeof(const_expression_t),
 		[EXPR_STRING_LITERAL]          = sizeof(string_literal_expression_t),
-		[EXPR_WIDE_STRING_LITERAL]   = sizeof(wide_string_literal_expression_t),
+		[EXPR_WIDE_STRING_LITERAL]     = sizeof(wide_string_literal_expression_t),
 		[EXPR_COMPOUND_LITERAL]        = sizeof(compound_literal_expression_t),
 		[EXPR_CALL]                    = sizeof(call_expression_t),
 		[EXPR_UNARY_FIRST]             = sizeof(unary_expression_t),
@@ -293,8 +295,7 @@ static size_t get_expression_struct_size(expression_kind_t kind)
 		[EXPR_SIZEOF]                  = sizeof(typeprop_expression_t),
 		[EXPR_ALIGNOF]                 = sizeof(typeprop_expression_t),
 		[EXPR_CLASSIFY_TYPE]           = sizeof(classify_type_expression_t),
-		[EXPR_FUNCTION]                = sizeof(string_literal_expression_t),
-		[EXPR_PRETTY_FUNCTION]         = sizeof(string_literal_expression_t),
+		[EXPR_FUNCNAME]                = sizeof(funcname_expression_t),
 		[EXPR_BUILTIN_SYMBOL]          = sizeof(builtin_symbol_expression_t),
 		[EXPR_BUILTIN_CONSTANT_P]      = sizeof(builtin_constant_expression_t),
 		[EXPR_BUILTIN_PREFETCH]        = sizeof(builtin_prefetch_expression_t),
@@ -938,32 +939,157 @@ static string_t parse_string_literals(void)
 	return result;
 }
 
+typedef enum gnu_attribute_kind_t {
+	GNU_AK_CONST,
+	GNU_AK_VOLATILE,
+	GNU_AK_CDECL,
+	GNU_AK_STDCALL,
+	GNU_AK_FASTCALL,
+	GNU_AK_DEPRECATED,
+	GNU_AK_NOINLINE,
+	GNU_AK_NORETURN,
+	GNU_AK_NAKED,
+	GNU_AK_PURE,
+	GNU_AK_ALWAYS_INLINE,
+	GNU_AK_MALLOC,
+	GNU_AK_WEAK,
+	GNU_AK_LAST
+} gnu_attribute_kind_t;
+
+static const char *gnu_attribute_names[GNU_AK_LAST] = {
+	[GNU_AK_CONST]         = "const",
+	[GNU_AK_VOLATILE]      = "volatile",
+	[GNU_AK_CDECL]         = "cdecl",
+	[GNU_AK_STDCALL]       = "stdcall",
+	[GNU_AK_FASTCALL]      = "fastcall",
+	[GNU_AK_DEPRECATED]    = "deprecated",
+	[GNU_AK_NOINLINE]      = "noinline",
+	[GNU_AK_NORETURN]      = "noreturn",
+	[GNU_AK_NAKED]         = "naked",
+	[GNU_AK_PURE]          = "pure",
+	[GNU_AK_ALWAYS_INLINE] = "always_inline",
+	[GNU_AK_MALLOC]        = "malloc",
+	[GNU_AK_WEAK]          = "weak",
+};
+
+/**
+ * compare two string, ignoring double underscores on the second.
+ */
+static int strcmp_underscore(const char *s1, const char *s2) {
+	if(s2[0] == '_' && s2[1] == '_') {
+		s2 += 2;
+		size_t l1 = strlen(s1);
+		if(l1 + 2 != strlen(s2)) {
+			/* not equal */
+			return 1;
+		}
+		return strncmp(s1, s2, l1);
+	}
+	return strcmp(s1, s2);
+}
+
+/**
+ * Parse one GNU attribute.
+ *
+ * Note that attribute names can be specified WITH or WITHOUT
+ * double underscores, ie const or __const__.
+ *
+ * The following attributes are parsed without arguments
+ *  const
+ *  volatile
+ *  cdecl
+ *  stdcall
+ *  fastcall
+ *  deprecated
+ *  noinline
+ *  noreturn
+ *  naked
+ *  pure
+ *  always_inline
+ *  malloc
+ *  weak
+ */
+static void parse_gnu_attribute(void)
+{
+	eat(T___attribute__);
+	expect('(');
+	expect('(');
+	while(true) {
+		const char *name;
+		if(token.type == T_const) {
+			name = "const";
+		} else if(token.type == T_volatile) {
+			name = "volatile";
+		} else if(token.type == T_cdecl) {
+			/* __attribute__((cdecl)), WITH ms mode */
+			name = "cdecl";
+		} else if(token.type != T_IDENTIFIER) {
+			parse_error_expected("while parsing GNU attribute", T_IDENTIFIER);
+			break;
+		}
+		const symbol_t *sym = token.v.symbol;
+		name = sym->string;
+		next_token();
+
+		gnu_attribute_kind_t kind;
+		for(kind = 0; kind < GNU_AK_LAST; ++kind) {
+			if(strcmp_underscore(gnu_attribute_names[kind], name) == 0)
+				break;
+		}
+		switch(kind) {
+		case GNU_AK_CONST:
+			break;
+		case GNU_AK_VOLATILE:
+			break;
+		case GNU_AK_CDECL:
+			break;
+		case GNU_AK_STDCALL:
+			break;
+		case GNU_AK_FASTCALL:
+			break;
+		case GNU_AK_DEPRECATED:
+			break;
+		case GNU_AK_NOINLINE:
+			break;
+		case GNU_AK_NORETURN:
+			break;
+		case GNU_AK_NAKED:
+			break;
+		case GNU_AK_PURE:
+			break;
+		case GNU_AK_ALWAYS_INLINE:
+			break;
+		case GNU_AK_MALLOC:
+			break;
+		case GNU_AK_WEAK:
+			break;
+		case GNU_AK_LAST:
+			warningf(HERE, "unrecognized attribute '%s'", name);
+
+			/* skip possible arguments */
+			if(token.type == '(')
+				eat_until_matching_token('(');
+			break;
+		}
+		if(token.type != ',')
+			break;
+		next_token();
+	}
+	expect(')');
+	expect(')');
+end_error:
+	return;
+}
+
+/**
+ * Parse GNU attributes.
+ */
 static void parse_attributes(void)
 {
 	while(true) {
 		switch(token.type) {
 		case T___attribute__: {
-			next_token();
-
-			expect('(');
-			int depth = 1;
-			while(depth > 0) {
-				switch(token.type) {
-				case T_EOF:
-					errorf(HERE, "EOF while parsing attribute");
-					break;
-				case '(':
-					next_token();
-					depth++;
-					break;
-				case ')':
-					next_token();
-					depth--;
-					break;
-				default:
-					next_token();
-				}
-			}
+			parse_gnu_attribute();
 			break;
 		}
 		case T_asm:
@@ -1149,8 +1275,8 @@ static initializer_t *parse_scalar_initializer(type_t *type,
 
 	if(initializer == NULL) {
 		errorf(expression->base.source_position,
-		       "expression '%E' doesn't match expected type '%T'",
-		       expression, type);
+		       "expression '%E' (type '%T') doesn't match expected type '%T'",
+		       expression, expression->base.type, type);
 		/* TODO */
 		return NULL;
 	}
@@ -1215,7 +1341,7 @@ static __attribute__((unused)) void debug_print_type_path(
 			}
 			fprintf(stderr, ".%s", entry->v.compound_entry->symbol->string);
 		} else if(is_type_array(type)) {
-			fprintf(stderr, "[%u]", entry->v.index);
+			fprintf(stderr, "[%zd]", entry->v.index);
 		} else {
 			fprintf(stderr, "-INVALID-");
 		}
@@ -1475,6 +1601,13 @@ static void skip_initializers(void)
 	}
 }
 
+static initializer_t *create_empty_initializer(void)
+{
+	static initializer_t empty_initializer
+		= { .list = { { INITIALIZER_LIST }, 0 } };
+	return &empty_initializer;
+}
+
 /**
  * Parse a part of an initialiser for a struct or union,
  */
@@ -1484,7 +1617,7 @@ static initializer_t *parse_sub_initializer(type_path_t *path,
 {
 	if(token.type == '}') {
 		/* empty initializer */
-		return NULL;
+		return create_empty_initializer();
 	}
 
 	type_t *orig_type = path->top_type;
@@ -1499,7 +1632,7 @@ static initializer_t *parse_sub_initializer(type_path_t *path,
 		 * initializers in this case. */
 		if(!is_type_valid(type)) {
 			skip_initializers();
-			return NULL;
+			return create_empty_initializer();
 		}
 	}
 
@@ -1988,9 +2121,14 @@ typedef enum {
 	SPECIFIER_FLOAT     = 1 << 8,
 	SPECIFIER_BOOL      = 1 << 9,
 	SPECIFIER_VOID      = 1 << 10,
+	SPECIFIER_INT8      = 1 << 11,
+	SPECIFIER_INT16     = 1 << 12,
+	SPECIFIER_INT32     = 1 << 13,
+	SPECIFIER_INT64     = 1 << 14,
+	SPECIFIER_INT128    = 1 << 15,
 #ifdef PROVIDE_COMPLEX
-	SPECIFIER_COMPLEX   = 1 << 11,
-	SPECIFIER_IMAGINARY = 1 << 12,
+	SPECIFIER_COMPLEX   = 1 << 16,
+	SPECIFIER_IMAGINARY = 1 << 17,
 #endif
 } specifiers_t;
 
@@ -2150,8 +2288,10 @@ static void parse_microsoft_extended_decl_modifier(declaration_specifiers_t *spe
 			expect(')');
 		} else if(symbol == sym_deprecated) {
 			next_token();
-			DET_MOD(deprecated, DM_DEPRECATED);
-               if(token.type == '(') {
+			if(specifiers->deprecated != 0)
+				warningf(HERE, "deprecated used more than once");
+			specifiers->deprecated = 1;
+			if(token.type == '(') {
 				next_token();
 				if(token.type == T_STRING_LITERAL) {
 					specifiers->deprecated_string = token.v.string.begin;
@@ -2206,7 +2346,7 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 		MATCH_STORAGE_CLASS(T_auto,     STORAGE_CLASS_AUTO)
 		MATCH_STORAGE_CLASS(T_register, STORAGE_CLASS_REGISTER)
 
-		case T_declspec:
+		case T__declspec:
 			next_token();
 			expect('(');
 			add_anchor_token(')');
@@ -2246,6 +2386,11 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 		MATCH_TYPE_QUALIFIER(T_const,    TYPE_QUALIFIER_CONST);
 		MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
 		MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
+		MATCH_TYPE_QUALIFIER(T__w64,     TYPE_QUALIFIER_W64);
+		MATCH_TYPE_QUALIFIER(T___ptr32,  TYPE_QUALIFIER_PTR32);
+		MATCH_TYPE_QUALIFIER(T___ptr64,  TYPE_QUALIFIER_PTR64);
+		MATCH_TYPE_QUALIFIER(T___uptr,   TYPE_QUALIFIER_UPTR);
+		MATCH_TYPE_QUALIFIER(T___sptr,   TYPE_QUALIFIER_SPTR);
 
 		case T___extension__:
 			/* TODO */
@@ -2272,11 +2417,16 @@ static void parse_declaration_specifiers(declaration_specifiers_t *specifiers)
 		MATCH_SPECIFIER(T_signed,     SPECIFIER_SIGNED,    "signed")
 		MATCH_SPECIFIER(T_unsigned,   SPECIFIER_UNSIGNED,  "unsigned")
 		MATCH_SPECIFIER(T__Bool,      SPECIFIER_BOOL,      "_Bool")
+		MATCH_SPECIFIER(T__int8,      SPECIFIER_INT8,      "_int8")
+		MATCH_SPECIFIER(T__int16,     SPECIFIER_INT16,     "_int16")
+		MATCH_SPECIFIER(T__int32,     SPECIFIER_INT32,     "_int32")
+		MATCH_SPECIFIER(T__int64,     SPECIFIER_INT64,     "_int64")
+		MATCH_SPECIFIER(T__int128,    SPECIFIER_INT128,    "_int128")
 #ifdef PROVIDE_COMPLEX
 		MATCH_SPECIFIER(T__Complex,   SPECIFIER_COMPLEX,   "_Complex")
 		MATCH_SPECIFIER(T__Imaginary, SPECIFIER_IMAGINARY, "_Imaginary")
 #endif
-		case T_forceinline:
+		case T__forceinline:
 			/* only in microsoft mode */
 			specifiers->decl_modifiers |= DM_FORCEINLINE;
 
@@ -2404,6 +2554,52 @@ finish_specifiers:
 			| SPECIFIER_INT:
 			atomic_type = ATOMIC_TYPE_ULONGLONG;
 			break;
+
+		case SPECIFIER_UNSIGNED | SPECIFIER_INT8:
+			atomic_type = unsigned_int8_type_kind;
+			break;
+
+		case SPECIFIER_UNSIGNED | SPECIFIER_INT16:
+			atomic_type = unsigned_int16_type_kind;
+			break;
+
+		case SPECIFIER_UNSIGNED | SPECIFIER_INT32:
+			atomic_type = unsigned_int32_type_kind;
+			break;
+
+		case SPECIFIER_UNSIGNED | SPECIFIER_INT64:
+			atomic_type = unsigned_int64_type_kind;
+			break;
+
+		case SPECIFIER_UNSIGNED | SPECIFIER_INT128:
+			atomic_type = unsigned_int128_type_kind;
+			break;
+
+		case SPECIFIER_INT8:
+		case SPECIFIER_SIGNED | SPECIFIER_INT8:
+			atomic_type = int8_type_kind;
+			break;
+
+		case SPECIFIER_INT16:
+		case SPECIFIER_SIGNED | SPECIFIER_INT16:
+			atomic_type = int16_type_kind;
+			break;
+
+		case SPECIFIER_INT32:
+		case SPECIFIER_SIGNED | SPECIFIER_INT32:
+			atomic_type = int32_type_kind;
+			break;
+
+		case SPECIFIER_INT64:
+		case SPECIFIER_SIGNED | SPECIFIER_INT64:
+			atomic_type = int64_type_kind;
+			break;
+
+		case SPECIFIER_INT128:
+		case SPECIFIER_SIGNED | SPECIFIER_INT128:
+			atomic_type = int128_type_kind;
+			break;
+
 		case SPECIFIER_FLOAT:
 			atomic_type = ATOMIC_TYPE_FLOAT;
 			break;
@@ -2469,6 +2665,7 @@ finish_specifiers:
 	}
 
 	type->base.qualifiers = type_qualifiers;
+	/* FIXME: check type qualifiers here */
 
 	type_t *result = typehash_insert(type);
 	if(newtype && result != type) {
@@ -2490,6 +2687,12 @@ static type_qualifiers_t parse_type_qualifiers(void)
 		MATCH_TYPE_QUALIFIER(T_const,    TYPE_QUALIFIER_CONST);
 		MATCH_TYPE_QUALIFIER(T_restrict, TYPE_QUALIFIER_RESTRICT);
 		MATCH_TYPE_QUALIFIER(T_volatile, TYPE_QUALIFIER_VOLATILE);
+		/* microsoft extended type modifiers */
+		MATCH_TYPE_QUALIFIER(T__w64,     TYPE_QUALIFIER_W64);
+		MATCH_TYPE_QUALIFIER(T___ptr32,  TYPE_QUALIFIER_PTR32);
+		MATCH_TYPE_QUALIFIER(T___ptr64,  TYPE_QUALIFIER_PTR64);
+		MATCH_TYPE_QUALIFIER(T___uptr,   TYPE_QUALIFIER_UPTR);
+		MATCH_TYPE_QUALIFIER(T___sptr,   TYPE_QUALIFIER_SPTR);
 
 		default:
 			return type_qualifiers;
@@ -2946,6 +3149,7 @@ static declaration_t *parse_declarator(
 	declaration_t *const declaration    = allocate_declaration_zero();
 	declaration->declared_storage_class = specifiers->declared_storage_class;
 	declaration->modifiers              = specifiers->decl_modifiers;
+	declaration->deprecated             = specifiers->deprecated;
 	declaration->deprecated_string      = specifiers->deprecated_string;
 	declaration->get_property_sym       = specifiers->get_property_sym;
 	declaration->put_property_sym       = specifiers->put_property_sym;
@@ -4210,6 +4414,22 @@ static expression_t *parse_reference(void)
 	/* this declaration is used */
 	declaration->used = true;
 
+	/* check for deprecated functions */
+	if(declaration->deprecated != 0) {
+		const char *prefix = "";
+		if (is_type_function(declaration->type))
+			prefix = "function ";
+
+		if (declaration->deprecated_string != NULL) {
+			warningf(source_position,
+				"%s'%Y' was declared 'deprecated(\"%s\")'", prefix, declaration->symbol,
+				declaration->deprecated_string);
+		} else {
+			warningf(source_position,
+				"%s'%Y' was declared 'deprecated'", prefix, declaration->symbol);
+		}
+	}
+
 	return expression;
 }
 
@@ -4343,8 +4563,9 @@ static expression_t *parse_function_keyword(void)
 		errorf(HERE, "'__func__' used outside of a function");
 	}
 
-	expression_t *expression = allocate_expression_zero(EXPR_FUNCTION);
-	expression->base.type    = type_char_ptr;
+	expression_t *expression  = allocate_expression_zero(EXPR_FUNCNAME);
+	expression->base.type     = type_char_ptr;
+	expression->funcname.kind = FUNCNAME_FUNCTION;
 
 	return expression;
 }
@@ -4352,14 +4573,44 @@ static expression_t *parse_function_keyword(void)
 static expression_t *parse_pretty_function_keyword(void)
 {
 	eat(T___PRETTY_FUNCTION__);
-	/* TODO */
 
 	if (current_function == NULL) {
 		errorf(HERE, "'__PRETTY_FUNCTION__' used outside of a function");
 	}
 
-	expression_t *expression = allocate_expression_zero(EXPR_PRETTY_FUNCTION);
-	expression->base.type    = type_char_ptr;
+	expression_t *expression  = allocate_expression_zero(EXPR_FUNCNAME);
+	expression->base.type     = type_char_ptr;
+	expression->funcname.kind = FUNCNAME_PRETTY_FUNCTION;
+
+	return expression;
+}
+
+static expression_t *parse_funcsig_keyword(void)
+{
+	eat(T___FUNCSIG__);
+
+	if (current_function == NULL) {
+		errorf(HERE, "'__FUNCSIG__' used outside of a function");
+	}
+
+	expression_t *expression  = allocate_expression_zero(EXPR_FUNCNAME);
+	expression->base.type     = type_char_ptr;
+	expression->funcname.kind = FUNCNAME_FUNCSIG;
+
+	return expression;
+}
+
+static expression_t *parse_funcdname_keyword(void)
+{
+	eat(T___FUNCDNAME__);
+
+	if (current_function == NULL) {
+		errorf(HERE, "'__FUNCDNAME__' used outside of a function");
+	}
+
+	expression_t *expression  = allocate_expression_zero(EXPR_FUNCNAME);
+	expression->base.type     = type_char_ptr;
+	expression->funcname.kind = FUNCNAME_FUNCDNAME;
 
 	return expression;
 }
@@ -4662,7 +4913,7 @@ end_error:
  * Parses a MS assume() expression.
  */
 static expression_t *parse_assume(void) {
-	eat(T_assume);
+	eat(T__assume);
 
 	expression_t *expression
 		= allocate_expression_zero(EXPR_UNARY_ASSUME);
@@ -4679,6 +4930,45 @@ end_error:
 	return create_invalid_expression();
 }
 
+/**
+ * Parse a microsoft __noop expression.
+ */
+static expression_t *parse_noop_expression(void) {
+	source_position_t source_position = HERE;
+	eat(T___noop);
+
+	if (token.type == '(') {
+		/* parse arguments */
+		eat('(');
+		add_anchor_token(')');
+		add_anchor_token(',');
+
+		if(token.type != ')') {
+			while(true) {
+				(void)parse_assignment_expression();
+				if(token.type != ',')
+					break;
+				next_token();
+			}
+		}
+	}
+	rem_anchor_token(',');
+	rem_anchor_token(')');
+	expect(')');
+
+	/* the result is a (int)0 */
+	expression_t *cnst         = allocate_expression_zero(EXPR_CONST);
+	cnst->base.source_position = source_position;
+	cnst->base.type            = type_int;
+	cnst->conste.v.int_value   = 0;
+	cnst->conste.is_ms_noop    = true;
+
+	return cnst;
+
+end_error:
+	return create_invalid_expression();
+}
+
 /**
  * Parses a primary expression.
  */
@@ -4695,6 +4985,8 @@ static expression_t *parse_primary_expression(void)
 		case T___FUNCTION__:
 		case T___func__:                 return parse_function_keyword();
 		case T___PRETTY_FUNCTION__:      return parse_pretty_function_keyword();
+		case T___FUNCSIG__:              return parse_funcsig_keyword();
+		case T___FUNCDNAME__:            return parse_funcdname_keyword();
 		case T___builtin_offsetof:       return parse_offsetof();
 		case T___builtin_va_start:       return parse_va_start();
 		case T___builtin_va_arg:         return parse_va_arg();
@@ -4712,9 +5004,10 @@ static expression_t *parse_primary_expression(void)
 		case T___builtin_isunordered:    return parse_compare_builtin();
 		case T___builtin_constant_p:     return parse_builtin_constant();
 		case T___builtin_prefetch:       return parse_builtin_prefetch();
-		case T_assume:                   return parse_assume();
+		case T__assume:                  return parse_assume();
 
 		case '(':                        return parse_brace_expression();
+		case T___noop:                   return parse_noop_expression();
 	}
 
 	errorf(HERE, "unexpected token %K, expected an expression", &token);
@@ -4913,6 +5206,7 @@ static expression_t *parse_call_expression(unsigned precedence,
 {
 	(void) precedence;
 	expression_t *result = allocate_expression_zero(EXPR_CALL);
+	result->base.source_position = expression->base.source_position;
 
 	call_expression_t *call = &result->call;
 	call->function          = expression;
@@ -5062,7 +5356,16 @@ static expression_t *parse_conditional_expression(unsigned precedence,
 
 	/* 6.5.15.3 */
 	type_t *result_type;
-	if (is_type_arithmetic(true_type) && is_type_arithmetic(false_type)) {
+	if(is_type_atomic(true_type, ATOMIC_TYPE_VOID) ||
+		is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
+		if (!is_type_atomic(true_type, ATOMIC_TYPE_VOID)
+				|| !is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
+			warningf(expression->base.source_position,
+					"ISO C forbids conditional expression with only one void side");
+		}
+		result_type = type_void;
+	} else if (is_type_arithmetic(true_type)
+			&& is_type_arithmetic(false_type)) {
 		result_type = semantic_arithmetic(true_type, false_type);
 
 		true_expression  = create_implicit_cast(true_expression, result_type);
@@ -5071,22 +5374,40 @@ static expression_t *parse_conditional_expression(unsigned precedence,
 		conditional->true_expression  = true_expression;
 		conditional->false_expression = false_expression;
 		conditional->base.type        = result_type;
-	} else if (same_compound_type(true_type, false_type) || (
-	    is_type_atomic(true_type, ATOMIC_TYPE_VOID) &&
-	    is_type_atomic(false_type, ATOMIC_TYPE_VOID)
-		)) {
+	} else if (same_compound_type(true_type, false_type)) {
 		/* just take 1 of the 2 types */
 		result_type = true_type;
-	} else if (is_type_pointer(true_type) && is_type_pointer(false_type)
-			&& pointers_compatible(true_type, false_type)) {
-		/* ok */
-		result_type = true_type;
-	} else if (is_type_pointer(true_type)
-			&& is_null_pointer_constant(false_expression)) {
-		result_type = true_type;
-	} else if (is_type_pointer(false_type)
-			&& is_null_pointer_constant(true_expression)) {
-		result_type = false_type;
+	} else if (is_type_pointer(true_type) || is_type_pointer(false_type)) {
+		type_t *pointer_type;
+		type_t *other_type;
+		expression_t *other_expression;
+		if (is_type_pointer(true_type)) {
+			pointer_type     = true_type;
+			other_type       = false_type;
+			other_expression = false_expression;
+		} else {
+			pointer_type     = false_type;
+			other_type       = true_type;
+			other_expression = true_expression;
+		}
+
+		if(is_type_pointer(other_type)) {
+			if(!pointers_compatible(true_type, false_type)) {
+				warningf(expression->base.source_position,
+						"pointer types '%T' and '%T' in conditional expression are incompatible", true_type, false_type);
+			}
+			result_type = true_type;
+		} else if(is_null_pointer_constant(other_expression)) {
+			result_type = pointer_type;
+		} else if(is_type_integer(other_type)) {
+			warningf(expression->base.source_position,
+					"pointer/integer type mismatch in conditional expression ('%T' and '%T')", true_type, false_type);
+			result_type = pointer_type;
+		} else {
+			type_error_incompatible("while parsing conditional",
+					expression->base.source_position, true_type, false_type);
+			result_type = type_error_type;
+		}
 	} else {
 		/* TODO: one pointer to void*, other some pointer */
 
@@ -5654,7 +5975,8 @@ static bool expression_has_effect(const expression_t *const expr)
 		case EXPR_UNKNOWN:                   break;
 		case EXPR_INVALID:                   return true; /* do NOT warn */
 		case EXPR_REFERENCE:                 return false;
-		case EXPR_CONST:                     return false;
+		/* suppress the warning for microsoft __noop operations */
+		case EXPR_CONST:                     return expr->conste.is_ms_noop;
 		case EXPR_CHARACTER_CONSTANT:        return false;
 		case EXPR_WIDE_CHARACTER_CONSTANT:   return false;
 		case EXPR_STRING_LITERAL:            return false;
@@ -5686,8 +6008,7 @@ static bool expression_has_effect(const expression_t *const expr)
 		case EXPR_CLASSIFY_TYPE:             return false;
 		case EXPR_ALIGNOF:                   return false;
 
-		case EXPR_FUNCTION:                  return false;
-		case EXPR_PRETTY_FUNCTION:           return false;
+		case EXPR_FUNCNAME:                  return false;
 		case EXPR_BUILTIN_SYMBOL:            break; /* handled in EXPR_CALL */
 		case EXPR_BUILTIN_CONSTANT_P:        return false;
 		case EXPR_BUILTIN_PREFETCH:          return true;