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

...and unused var warnings.

Mostly changed int to size_t or used static_cast, and commented out
the unused variables.

src/ai.cpp

@@ -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)));
 		}
 

src/callable_objects.hpp

@@ -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

src/config.cpp

@@ -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]);
 		}
 	}

src/display.cpp

@@ -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));

src/formula.cpp

@@ -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);

src/formula_ai.cpp

@@ -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 {

src/formula_function.cpp

@@ -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";
 			}
 		}

src/formula_function.hpp

@@ -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();
 		}

src/soundsource.cpp

@@ -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;

src/unit_frame.cpp

@@ -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) {

src/variant.cpp

@@ -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 << ", ";