character.h: In member function 'void char_data::WAIT_STATE(int)':
character.h:461: error: conversion to 'short int' from 'int' may alter its value

GCC Release Notes said:

The -Wconversion option has been modified. Its purpose now is to warn for implicit conversions that may alter a value. This new behavior is available for both C and C++. Warnings about conversions between signed and unsigned integers can be disabled by using -Wno-sign-conversion. In C++, they are disabled by default unless -Wsign-conversion is explicitly requested. The old behavior of -Wconversion, that is, warn for prototypes causing a type conversion that is different from what would happen to the same argument in the absence of a prototype, has been moved to a new option -Wtraditional-conversion, which is only available for C.

DavidHaley said:

Now, as for what Caius posted, it is pretty messed up that that fails. (Are you sure that the error comes from the +=, and it's not trying to return that value or something like that? What if you put return 0 at the end?)

Caius said:

Here's a real kicker. Try this little program with the -Wconversion flag on gcc 4.3:

int main()
{
  short x = 1;
  short y = 2;
  x += y;
}

The compiler will complain that you're trying to convert a short int to an int, even though they are both shortS! Apparently operators like += will promote the values to int implicitly. From what I've been told this is supposed to be correct behaviour, but it seems rather odd to me. Not even casting the rvalue will help. I believe the only thing you can do now is to either remove the -Wconversion flag, or the -Werror flag and live with the warning. Really annoying.

Samson said:

It's complaining about returning an int when all the variables inside are shorts. Which I think is ludicrous, and I don't care how "correct" it seems, in practice it's just a colossal waste of time. And yes, even more of a waste of developer time than the const issue was. Because at least the const issue had some glimmer of an argument for correctness. This though, this is stupider than using -pedantic.

Keberus said:

Sounds like the += is meant for integers instead of shorts, maybe (at least if you're compiling with C++ ) you could overload the += operator. Not sure how to do it myself, but I am pretty sure it can be done.

Caius said:

Yes, you can overload operators for user-defined types/classes. You can also overload how your types works with fundamental types. For example, say you're making a class called HugeInteger that can hold astronomical numbers. You can then overload its operators such that you can use it with intS and shortS and such:

HugeInteger x = 10000000000000000000000000;
int y = 4567;
x += y; // x == 10000000000000000000004567

So you can overload your own types, how they work with eachother, and how they work with fundamental types. But you can not alter the normal behaviour of the latter.

Samson said:

It's complaining about returning an int when all the variables inside are shorts. Which I think is ludicrous, and I don't care how "correct" it seems, in practice it's just a colossal waste of time. And yes, even more of a waste of developer time than the const issue was. Because at least the const issue had some glimmer of an argument for correctness. This though, this is stupider than using -pedantic.