0ct0pu5/wesnoth
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Worked around a number of signed/unisgned comparison warnings...

Browse source 
...and unused var warnings.

Mostly changed int to size_t or used static_cast, and commented out
the unused variables.
This commit is contained in:
Tomasz Śniatowski 2008-04-06 16:47:16 +01:00
parent 6daf1021eb
commit 9869a97a66
11 changed files with 45 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/ai.cpp
View file

@ -2258,7 +2258,7 @@ variant ai::attack_analysis::get_value(const std::string& key) const
return variant(new location_callable(target));
} else if(key == "movements") {
std::vector<variant> res;
for(int n = 0; n != movements.size(); ++n) {
for(size_t n = 0; n != movements.size(); ++n) {
map_formula_callable* item = new map_formula_callable(NULL);
item->add("src", variant(new location_callable(movements[n].first)));
item->add("dst", variant(new location_callable(movements[n].second)));
@ -2268,7 +2268,7 @@ variant ai::attack_analysis::get_value(const std::string& key) const
return variant(&res);
} else if(key == "units") {
std::vector<variant> res;
for(int n = 0; n != movements.size(); ++n) {
for(size_t n = 0; n != movements.size(); ++n) {
res.push_back(variant(new location_callable(movements[n].first)));
}

4
src/callable_objects.hpp
View file

@ -127,7 +127,7 @@ public:
class unit_callable : public game_logic::formula_callable {
public:
typedef gamemap::location location;
unit_callable(const std::pair<location, unit>& pair, const team& current_team, int side)
unit_callable(const std::pair<location, unit>& pair, const team& current_team, unsigned int side)
: loc_(pair.first), u_(pair.second), team_(current_team), side_(side)
{}
@ -138,7 +138,7 @@ private:
const location& loc_;
const unit& u_;
const team& team_;
int side_;
unsigned int side_;
};
#endif

2
src/config.cpp
View file

@ -640,7 +640,7 @@ void config::merge_and_keep(const config& c)
const std::string& tag = i->first;
child_map::const_iterator j = children.find(tag);
if (j == children.end()) {
for (int count=0; count < i->second.size(); count++)
for (size_t count=0; count < i->second.size(); count++)
add_child(tag, *i->second[count]);
}
}

2
src/display.cpp
View file

@ -2016,7 +2016,7 @@ void display::refresh_report(reports::TYPE report_num, reports::report report,
}
void display::invalidate_rectangle(const gamemap::location& first_corner, const gamemap::location& second_corner) {
const SDL_Rect& rect = map_area();
// unused variable - const SDL_Rect& rect = map_area();
for (int x = minimum<int>(first_corner.x,second_corner.x); x <= maximum<int>(first_corner.x,second_corner.x);x++) {
for (int y = minimum<int>(first_corner.y,second_corner.y); y <= maximum<int>(first_corner.y,second_corner.y);y++) {
invalidate(gamemap::location(x,y));

4
src/formula.cpp
View file

@ -79,7 +79,7 @@ private:
std::vector<std::string> function_names = builtin_function_names();
std::vector<std::string> more_function_names = symbols_->get_function_names();
function_names.insert(function_names.end(), more_function_names.begin(), more_function_names.end());
for(int i = 0; i < function_names.size(); i++) {
for(size_t i = 0; i < function_names.size(); i++) {
res.push_back(variant(function_names[i]));
}
return variant(&res);
@ -378,7 +378,7 @@ private:
return str_;
} else {
std::string res = str_.as_string();
for(int i=0; i < subs_.size(); ++i) {
for(size_t i=0; i < subs_.size(); ++i) {
const substitution& sub = subs_[i];
const std::string str = sub.calculation->execute(variables).string_cast();
res.insert(sub.pos, str);

10
src/formula_ai.cpp
View file

@ -128,7 +128,7 @@ private:
int best = 1000000;
int best_i = -1;
for(int i = 0; i < items.num_elements(); ++i) {
for(size_t i = 0; i < items.num_elements(); ++i) {
const gamemap::location move_loc = convert_variant<location_callable>(items[i])->loc();
int distance = distance_between(loc, move_loc);
@ -192,7 +192,7 @@ private:
variant execute(const formula_callable& variables) const {
std::vector<variant> vars;
const gamemap::location loc = convert_variant<location_callable>(args()[0]->evaluate(variables))->loc();
int range = args()[1]->evaluate(variables).as_int();
size_t range = static_cast<size_t>(args()[1]->evaluate(variables).as_int());
unit_map::const_iterator un = ai_.get_info().units.begin();
unit_map::const_iterator end = ai_.get_info().units.end();
while (un != end) {
@ -220,7 +220,7 @@ private:
variant attack = args()[0]->evaluate(variables);
ai::attack_analysis* analysis = convert_variant<ai::attack_analysis>(attack);
unit_map units_with_moves(ai_.get_info().units);
for(int n = 0; n != analysis->movements.size(); ++n) {
for(size_t n = 0; n != analysis->movements.size(); ++n) {
std::pair<gamemap::location,unit>* pair = units_with_moves.extract(analysis->movements[n].first);
pair->first = analysis->movements[n].second;
units_with_moves.add(pair);
@ -795,7 +795,7 @@ bool formula_ai::execute_variant(const variant& var, bool commandline)
{
std::vector<variant> vars;
if(var.is_list()) {
for(int n = 0; n != var.num_elements(); ++n) {
for(size_t n = 0; n != var.num_elements(); ++n) {
vars.push_back(var[n]);
}
} else {
@ -916,7 +916,7 @@ void formula_ai::do_recruitment()
variant var = recruit_formula_->execute(*this);
std::vector<variant> vars;
if(var.is_list()) {
for(int n = 0; n != var.num_elements(); ++n) {
for(size_t n = 0; n != var.num_elements(); ++n) {
vars.push_back(var[n]);
}
} else {

40
src/formula_function.cpp
View file

@ -41,7 +41,7 @@ private:
const formula_callable* callable = var.as_callable();
std::vector<formula_input> inputs = callable->inputs();
std::vector<variant> res;
for(int i=0; i<inputs.size(); ++i) {
for(size_t i=0; i<inputs.size(); ++i) {
const formula_input& input = inputs[i];
res.push_back(variant(input.name));
}
@ -72,7 +72,7 @@ public:
private:
variant execute(const formula_callable& variables) const {
variant var = args()[0]->evaluate(variables);
for(int n = 1; n < args().size()-1; n += 2) {
for(size_t n = 1; n < args().size()-1; n += 2) {
variant val = args()[n]->evaluate(variables);
if(val == var) {
return args()[n+1]->evaluate(variables);
@ -149,7 +149,7 @@ private:
const int value = args()[0]->evaluate(variables).as_int();
int begin = args()[1]->evaluate(variables).as_int();
int end = -1;
int n = 3;
size_t n = 3;
while(n < args().size()) {
end = args()[n]->evaluate(variables).as_int();
if(value >= begin && value <= end) {
@ -207,10 +207,10 @@ private:
variant execute(const formula_callable& variables) const {
bool found = false;
int res = 0;
for(int n = 0; n != args().size(); ++n) {
for(size_t n = 0; n != args().size(); ++n) {
const variant v = args()[n]->evaluate(variables);
if(v.is_list()) {
for(int m = 0; m != v.num_elements(); ++m) {
for(size_t m = 0; m != v.num_elements(); ++m) {
if(!found || v[m].as_int() < res) {
res = v[m].as_int();
found = true;
@ -238,10 +238,10 @@ private:
variant execute(const formula_callable& variables) const {
bool found = false;
int res = 0;
for(int n = 0; n != args().size(); ++n) {
for(size_t n = 0; n != args().size(); ++n) {
const variant v = args()[n]->evaluate(variables);
if(v.is_list()) {
for(int m = 0; m != v.num_elements(); ++m) {
for(size_t m = 0; m != v.num_elements(); ++m) {
if(!found || v[m].as_int() > res) {
res = v[m].as_int();
found = true;
@ -270,7 +270,7 @@ private:
const variant items = args()[0]->evaluate(variables);
int max_index = -1;
variant max_value;
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
const variant val = args()[1]->evaluate(formula_variant_callable_with_backup(items[n], variables));
if(max_index == -1 || val > max_value) {
max_index = n;
@ -341,7 +341,7 @@ private:
variant list = args()[0]->evaluate(variables);
std::vector<variant> vars;
vars.reserve(list.num_elements());
for(int n = 0; n != list.num_elements(); ++n) {
for(size_t n = 0; n != list.num_elements(); ++n) {
vars.push_back(list[n]);
}
@ -365,7 +365,7 @@ private:
std::vector<variant> vars;
const variant items = args()[0]->evaluate(variables);
if(args().size() == 2) {
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
const variant val = args()[1]->evaluate(formula_variant_callable_with_backup(items[n], variables));
if(val.as_bool()) {
vars.push_back(items[n]);
@ -374,7 +374,7 @@ private:
} else {
map_formula_callable self_callable;
const std::string self = args()[1]->evaluate(variables).as_string();
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
self_callable.add(self, items[n]);
const variant val = args()[2]->evaluate(formula_callable_with_backup(self_callable, formula_variant_callable_with_backup(items[n], variables)));
if(val.as_bool()) {
@ -398,7 +398,7 @@ private:
const variant items = args()[0]->evaluate(variables);
if(args().size() == 2) {
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
const variant val = args()[1]->evaluate(formula_variant_callable_with_backup(items[n], variables));
if(val.as_bool()) {
return items[n];
@ -407,7 +407,7 @@ private:
} else {
map_formula_callable self_callable;
const std::string self = args()[1]->evaluate(variables).as_string();
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
self_callable.add(self, items[n]);
const variant val = args().back()->evaluate(formula_callable_with_backup(self_callable, formula_variant_callable_with_backup(items[n], variables)));
if(val.as_bool()) {
@ -431,14 +431,14 @@ private:
const variant items = args()[0]->evaluate(variables);
if(args().size() == 2) {
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
const variant val = args().back()->evaluate(formula_variant_callable_with_backup(items[n], variables));
vars.push_back(val);
}
} else {
map_formula_callable self_callable;
const std::string self = args()[1]->evaluate(variables).as_string();
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
self_callable.add(self, items[n]);
const variant val = args().back()->evaluate(formula_callable_with_backup(self_callable, formula_variant_callable_with_backup(items[n], variables)));
vars.push_back(val);
@ -461,7 +461,7 @@ private:
if(args().size() >= 2) {
res = args()[1]->evaluate(variables);
}
for(int n = 0; n != items.num_elements(); ++n) {
for(size_t n = 0; n != items.num_elements(); ++n) {
res = res + items[n];
}
@ -532,7 +532,7 @@ formula_function_expression::formula_function_expression(const std::string& name
: function_expression(name, args, arg_names.size(), arg_names.size()),
formula_(formula), precondition_(precondition), arg_names_(arg_names), star_arg_(-1)
{
for(int n = 0; n != arg_names_.size(); ++n) {
for(size_t n = 0; n != arg_names_.size(); ++n) {
if(arg_names_.empty() == false && arg_names_[n][arg_names_[n].size()-1] == '*') {
arg_names_[n].resize(arg_names_[n].size()-1);
star_arg_ = n;
@ -548,10 +548,10 @@ variant formula_function_expression::execute(const formula_callable& variables)
std::cerr << indent << "executing '" << formula_->str() << "'\n";
const int begin_time = SDL_GetTicks();
map_formula_callable callable;
for(int n = 0; n != arg_names_.size(); ++n) {
for(size_t n = 0; n != arg_names_.size(); ++n) {
variant var = args()[n]->evaluate(variables);
callable.add(arg_names_[n], var);
if(n == star_arg_) {
if(static_cast<int>(n) == star_arg_) {
callable.set_fallback(var.as_callable());
}
}
@ -559,7 +559,7 @@ variant formula_function_expression::execute(const formula_callable& variables)
if(precondition_) {
if(!precondition_->execute(callable).as_bool()) {
std::cerr << "FAILED function precondition for function '" << formula_->str() << "' with arguments: ";
for(int n = 0; n != arg_names_.size(); ++n) {
for(size_t n = 0; n != arg_names_.size(); ++n) {
std::cerr << " arg " << (n+1) << ": " << args()[n]->evaluate(variables).to_debug_string() << "\n";
}
}

4
src/formula_function.hpp
View file

@ -50,12 +50,12 @@ public:
: name_(name), args_(args)
{
set_name(name.c_str());
if(min_args != -1 && args_.size() < min_args) {
if(min_args != -1 && args_.size() < static_cast<size_t>(min_args)) {
std::cerr << "too few arguments\n";
throw formula_error();
}
if(max_args != -1 && args_.size() > max_args) {
if(max_args != -1 && args_.size() > static_cast<size_t>(max_args)) {
std::cerr << "too many arguments\n";
throw formula_error();
}

2
src/soundsource.cpp
View file

@ -174,7 +174,7 @@ int positional_source::calculate_volume(const gamemap::location &loc, const disp
SDL_Rect area = disp.map_area();
gamemap::location center = disp.hex_clicked_on(area.x + area.w / 2, area.y + area.h / 2);
int distance = distance_between(loc, center);
size_t distance = distance_between(loc, center);
if(distance <= _range) {
return 0;

2
src/unit_frame.cpp
View file

@ -415,7 +415,7 @@ void unit_frame::invalidate(const int frame_time,const gamemap::location & src,c
const frame_parameters current_data = builder_.parameters(frame_time,default_val);
double tmp_offset = current_data.offset;
int d2 = game_display::get_singleton()->hex_size() / 2;
//unused var - int d2 = game_display::get_singleton()->hex_size() / 2;
image::locator image_loc;
if(direction != gamemap::location::NORTH && direction != gamemap::location::SOUTH) {

16
src/variant.cpp
View file

@ -247,12 +247,12 @@ variant variant::operator+(const variant& v) const
if(v.type_ == TYPE_LIST) {
std::vector<variant> res;
res.reserve(list_->elements.size() + v.list_->elements.size());
for(int i = 0; i<list_->elements.size(); ++i) {
for(size_t i = 0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
res.push_back(var);
}
for(int j = 0; j<v.list_->elements.size(); ++j) {
for(size_t j = 0; j<v.list_->elements.size(); ++j) {
const variant& var = v.list_->elements[j];
res.push_back(var);
}
@ -330,7 +330,7 @@ bool variant::operator==(const variant& v) const
return false;
}
for(int n = 0; n != num_elements(); ++n) {
for(size_t n = 0; n != num_elements(); ++n) {
if((*this)[n] != v[n]) {
return false;
}
@ -381,7 +381,7 @@ bool variant::operator<=(const variant& v) const
}
case TYPE_LIST: {
for(int n = 0; n != num_elements() && n != v.num_elements(); ++n) {
for(size_t n = 0; n != num_elements() && n != v.num_elements(); ++n) {
if((*this)[n] < v[n]) {
return true;
} else if((*this)[n] > v[n]) {
@ -437,7 +437,7 @@ void variant::serialize_to_string(std::string& str) const
case TYPE_LIST: {
str += "[";
bool first_time = true;
for(int i=0; i<list_->elements.size(); ++i) {
for(size_t i=0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
if(!first_time) {
str += ",";
@ -495,7 +495,7 @@ std::string variant::string_cast() const
return "(object)";
case TYPE_LIST: {
std::string res = "";
for(int i=0; i<list_->elements.size(); ++i) {
for(size_t i=0; i<list_->elements.size(); ++i) {
const variant& var = list_->elements[i];
if(!res.empty()) {
res += ", ";
@ -531,7 +531,7 @@ std::string variant::to_debug_string(std::vector<const game_logic::formula_calla
break;
case TYPE_LIST: {
s << "[";
for(int n = 0; n != num_elements(); ++n) {
for(size_t n = 0; n != num_elements(); ++n) {
if(n != 0) {
s << ", ";
}
@ -547,7 +547,7 @@ std::string variant::to_debug_string(std::vector<const game_logic::formula_calla
seen->push_back(callable_);
std::vector<game_logic::formula_input> v = callable_->inputs();
bool first = true;
for(int i=0; i<v.size(); ++i) {
for(size_t i=0; i<v.size(); ++i) {
const game_logic::formula_input& input = v[i];
if(!first) {
s << ", ";