openttd-ottdgrfs: comparison src/newgrf.cpp

equal deleted inserted replaced

-:2e867a1c6b7f
+:b4f6595855c4
 };
 typedef void (*SpecialSpriteHandler)(byte *buf, int len);
-static const int _vehcounts[4] = {
+static const uint _vehcounts[4] = {
 	/* GSF_TRAIN */    NUM_TRAIN_ENGINES,
 	/* GSF_ROAD */     NUM_ROAD_ENGINES,
 	/* GSF_SHIP */     NUM_SHIP_ENGINES,
 	/* GSF_AIRCRAFT */ NUM_AIRCRAFT_ENGINES
 };
-static const int _vehshifts[4] = {
+static const uint _vehshifts[4] = {
 	/* GSF_TRAIN */    0,
 	/* GSF_ROAD */     ROAD_ENGINES_INDEX,
 	/* GSF_SHIP */     SHIP_ENGINES_INDEX,
 	/* GSF_AIRCRAFT */ AIRCRAFT_ENGINES_INDEX,
 };
 	}
 	switch (prop) {
 		case 0x08: /* Class ID */
 			FOR_EACH_OBJECT {
-				uint32 classid;
 				/* Property 0x08 is special; it is where the station is allocated */
 				if (statspec[i] == NULL) statspec[i] = CallocT<StationSpec>(1);
 				/* Swap classid because we read it in BE meaning WAYP or DFLT */
-				classid = grf_load_dword(&buf);
+				uint32 classid = grf_load_dword(&buf);
 				statspec[i]->sclass = AllocateStationClass(BSWAP32(classid));
 			}
 			break;
 		case 0x09: /* Define sprite layout */
 			FOR_EACH_OBJECT {
 				StationSpec *statspec = _cur_grffile->stations[stid + i];
-				uint t;
 				statspec->tiles = grf_load_extended(&buf);
 				statspec->renderdata = CallocT<DrawTileSprites>(statspec->tiles);
 				statspec->copied_renderdata = false;
-				for (t = 0; t < statspec->tiles; t++) {
+				for (uint t = 0; t < statspec->tiles; t++) {
 					DrawTileSprites *dts = &statspec->renderdata[t];
 					uint seq_count = 0;
 					dts->seq = NULL;
 					dts->ground_sprite = grf_load_word(&buf);
 					/* Allocate memory for sprite table pointers and zero out */
 					bridge->sprite_table = CallocT<PalSpriteID*>(7);
 				}
 				for (; numtables-- != 0; tableid++) {
-					byte sprite;
 					if (tableid >= 7) { // skip invalid data
 						grfmsg(1, "BridgeChangeInfo: Table %d >= 7, skipping", tableid);
-						for (sprite = 0; sprite < 32; sprite++) grf_load_dword(&buf);
+						for (byte sprite = 0; sprite < 32; sprite++) grf_load_dword(&buf);
 						continue;
 					}
 					if (bridge->sprite_table[tableid] == NULL) {
 						bridge->sprite_table[tableid] = MallocT<PalSpriteID>(32);
 					}
-					for (sprite = 0; sprite < 32; sprite++) {
+					for (byte sprite = 0; sprite < 32; sprite++) {
 						SpriteID image = grf_load_word(&buf);
 						SpriteID pal   = grf_load_word(&buf);
 						if (HASBIT(pal, 15)) {
 							SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
 		/* GSF_INDUSTRIES */   NULL,
 		/* GSF_CARGOS */       NULL,
 		/* GSF_SOUNDFX */      SoundEffectChangeInfo,
 	};
-	uint8 feature;
-	uint8 numprops;
-	uint8 numinfo;
-	byte engine;
 	EngineInfo *ei = NULL;
 	if (len == 1) {
 		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
 		return;
 	}
 	if (!check_length(len, 6, "FeatureChangeInfo")) return;
 	buf++;
-	feature  = grf_load_byte(&buf);
+	uint8 feature  = grf_load_byte(&buf);
-	numprops = grf_load_byte(&buf);
+	uint8 numprops = grf_load_byte(&buf);
-	numinfo  = grf_load_byte(&buf);
+	uint8 numinfo  = grf_load_byte(&buf);
-	engine   = grf_load_byte(&buf);
+	uint8 engine   = grf_load_byte(&buf);
 	grfmsg(6, "FeatureChangeInfo: feature %d, %d properties, to apply to %d+%d",
 	               feature, numprops, engine, numinfo);
 	if (feature >= lengthof(handler) || handler[feature] == NULL) {
 						 * credit ;-). --pasky */
 						FOR_EACH_OBJECT ei[i].load_amount = grf_load_byte(&buf);
 						break;
 					default:
-						if (handler[feature](engine, numinfo, prop, &buf, bufend - buf))
+						if (handler[feature](engine, numinfo, prop, &buf, bufend - buf)) {
 							ignoring = true;
+						}
 						break;
 				}
 				break;
 			default:
-				if (handler[feature](engine, numinfo, prop, &buf, bufend - buf))
+				if (handler[feature](engine, numinfo, prop, &buf, bufend - buf)) {
 					ignoring = true;
+				}
 				break;
 		}
 		if (ignoring) grfmsg(2, "FeatureChangeInfo: Ignoring property 0x%02X (not implemented)", prop);
 	}
 }
 /* Action 0x00 (GLS_SAFETYSCAN) */
 static void SafeChangeInfo(byte *buf, int len)
 {
-	uint8 feature;
-	uint8 numprops;
-	uint8 numinfo;
-	uint8 index;
 	if (len == 1) {
 		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
 		return;
 	}
 	if (!check_length(len, 6, "SafeChangeInfo")) return;
 	buf++;
-	feature  = grf_load_byte(&buf);
+	uint8 feature  = grf_load_byte(&buf);
-	numprops = grf_load_byte(&buf);
+	uint8 numprops = grf_load_byte(&buf);
-	numinfo  = grf_load_byte(&buf);
+	grf_load_byte(&buf);
-	index    = grf_load_byte(&buf);
+	grf_load_byte(&buf);
 	if (feature == GSF_BRIDGE && numprops == 1) {
 		uint8 prop = grf_load_byte(&buf);
 		/* Bridge property 0x0D is redefinition of sprite layout tables, which
 		 * is considered safe. */
 /* Action 0x00 (GLS_INIT) */
 static void InitChangeInfo(byte *buf, int len)
 {
 	byte *bufend = buf + len;
-	uint8 feature;
-	uint8 numprops;
-	uint8 numinfo;
-	uint8 index;
 	if (len == 1) {
 		grfmsg(8, "Silently ignoring one-byte special sprite 0x00");
 		return;
 	}
 	if (!check_length(len, 6, "InitChangeInfo")) return;
 	buf++;
-	feature  = grf_load_byte(&buf);
+	uint8 feature  = grf_load_byte(&buf);
-	numprops = grf_load_byte(&buf);
+	uint8 numprops = grf_load_byte(&buf);
-	numinfo  = grf_load_byte(&buf);
+	uint8 numinfo  = grf_load_byte(&buf);
-	index    = grf_load_byte(&buf);
+	uint8 index    = grf_load_byte(&buf);
 	while (numprops-- && buf < bufend) {
 		uint8 prop = grf_load_byte(&buf);
 		switch (feature) {
 	 * E num-ent       how many entries per sprite set
 	 *                 For vehicles, this is the number of different
 	 *                         vehicle directions in each sprite set
 	 *                         Set num-dirs=8, unless your sprites are symmetric.
 	 *                         In that case, use num-dirs=4.
-	 *                 For stations, must be 12 (hex) for the eighteen
+	 */
-	 *                         different sprites that make up a station */
-	/* TODO: No stations support. */
-	uint8 feature;
-	uint num_sets;
-	uint num_ents;
-	uint i;
 	if (!check_length(len, 4, "NewSpriteSet")) return;
 	buf++;
-	feature  = grf_load_byte(&buf);
+	uint8 feature   = grf_load_byte(&buf);
-	num_sets = grf_load_byte(&buf);
+	uint8 num_sets  = grf_load_byte(&buf);
-	num_ents = grf_load_extended(&buf);
+	uint16 num_ents = grf_load_extended(&buf);
 	_cur_grffile->spriteset_start = _cur_spriteid;
 	_cur_grffile->spriteset_feature = feature;
 	_cur_grffile->spriteset_numsets = num_sets;
 	_cur_grffile->spriteset_numents = num_ents;
 	grfmsg(7, "New sprite set at %d of type %d, consisting of %d sets with %d views each (total %d)",
 		_cur_spriteid, feature, num_sets, num_ents, num_sets * num_ents
 	);
-	for (i = 0; i < num_sets * num_ents; i++) {
+	for (uint i = 0; i < num_sets * num_ents; i++) {
 		LoadNextSprite(_cur_spriteid++, _file_index);
 		_nfo_line++;
 	}
 }
 	 *                 if 80 or greater, this is a randomized or variational
 	 *                 list definition, see below
 	 *                 otherwise it specifies a number of entries, the exact
 	 *                 meaning depends on the feature
 	 * V feature-specific-data (huge mess, don't even look it up --pasky) */
-	uint8 feature;
-	uint8 setid;
-	uint8 type;
 	SpriteGroup *group = NULL;
 	byte *bufend = buf + len;
 	if (!check_length(len, 5, "NewSpriteGroup")) return;
 	buf++;
-	feature = grf_load_byte(&buf);
+	uint8 feature = grf_load_byte(&buf);
-	setid   = grf_load_byte(&buf);
+	uint8 setid   = grf_load_byte(&buf);
-	type    = grf_load_byte(&buf);
+	uint8 type    = grf_load_byte(&buf);
 	if (setid >= _cur_grffile->spritegroups_count) {
 		// Allocate memory for new sprite group references.
 		_cur_grffile->spritegroups = ReallocT(_cur_grffile->spritegroups, setid + 1);
 		// Initialise new space to NULL
 		case 0x89: // Self scope, dword
 		case 0x8A: // Parent scope, dword
 		{
 			byte varadjust;
 			byte varsize;
-			uint i;
 			/* Check we can load the var size parameter */
 			if (!check_length(bufend - buf, 1, "NewSpriteGroup (Deterministic) (1)")) return;
 			group = AllocateSpriteGroup();
 			group->g.determ.num_ranges = grf_load_byte(&buf);
 			group->g.determ.ranges = CallocT<DeterministicSpriteGroupRange>(group->g.determ.num_ranges);
 			if (!check_length(bufend - buf, 2 + (2 + 2 * varsize) * group->g.determ.num_ranges, "NewSpriteGroup (Deterministic)")) return;
-			for (i = 0; i < group->g.determ.num_ranges; i++) {
+			for (uint i = 0; i < group->g.determ.num_ranges; i++) {
 				group->g.determ.ranges[i].group = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
 				group->g.determ.ranges[i].low   = grf_load_var(varsize, &buf);
 				group->g.determ.ranges[i].high  = grf_load_var(varsize, &buf);
 			}
 		/* Randomized Sprite Group */
 		case 0x80: // Self scope
 		case 0x83: // Parent scope
 		{
-			byte triggers;
-			uint i;
 			if (!check_length(bufend - buf, 7, "NewSpriteGroup (Randomized) (1)")) return;
 			group = AllocateSpriteGroup();
 			group->type = SGT_RANDOMIZED;
 			group->g.random.var_scope = HASBIT(type, 1) ? VSG_SCOPE_PARENT : VSG_SCOPE_SELF;
-			triggers = grf_load_byte(&buf);
+			uint8 triggers = grf_load_byte(&buf);
 			group->g.random.triggers       = GB(triggers, 0, 7);
 			group->g.random.cmp_mode       = HASBIT(triggers, 7) ? RSG_CMP_ALL : RSG_CMP_ANY;
 			group->g.random.lowest_randbit = grf_load_byte(&buf);
 			group->g.random.num_groups     = grf_load_byte(&buf);
 			group->g.random.groups = CallocT<const SpriteGroup*>(group->g.random.num_groups);
 			if (!check_length(bufend - buf, 2 * group->g.random.num_groups, "NewSpriteGroup (Randomized) (2)")) return;
-			for (i = 0; i < group->g.random.num_groups; i++) {
+			for (uint i = 0; i < group->g.random.num_groups; i++) {
 				group->g.random.groups[i] = GetGroupFromGroupID(setid, type, grf_load_word(&buf));
 			}
 			break;
 		}
 				case GSF_STATION:
 				{
 					byte sprites     = _cur_grffile->spriteset_numents;
 					byte num_loaded  = type;
 					byte num_loading = grf_load_byte(&buf);
-					uint i;
 					if (_cur_grffile->spriteset_start == 0) {
 						grfmsg(0, "NewSpriteGroup: No sprite set to work on! Skipping");
 						return;
 					}
 					if (num_loading > 0) group->g.real.loading = CallocT<const SpriteGroup*>(num_loading);
 					grfmsg(6, "NewSpriteGroup: New SpriteGroup 0x%02X, %u views, %u loaded, %u loading",
 							setid, sprites, num_loaded, num_loading);
-					for (i = 0; i < num_loaded; i++) {
+					for (uint i = 0; i < num_loaded; i++) {
 						uint16 spriteid = grf_load_word(&buf);
 						group->g.real.loaded[i] = CreateGroupFromGroupID(feature, setid, type, spriteid, sprites);
 						grfmsg(8, "NewSpriteGroup: + rg->loaded[%i]  = subset %u", i, spriteid);
 					}
-					for (i = 0; i < num_loading; i++) {
+					for (uint i = 0; i < num_loading; i++) {
 						uint16 spriteid = grf_load_word(&buf);
 						group->g.real.loading[i] = CreateGroupFromGroupID(feature, setid, type, spriteid, sprites);
 						grfmsg(8, "NewSpriteGroup: + rg->loading[%i] = subset %u", i, spriteid);
 					}
 	/* TODO: Multiple cargo support could be useful even for trains/cars -
 	 * cargo id 0xff is used for showing images in the build train list. */
 	static byte *last_engines;
 	static int last_engines_count;
-	uint8 feature;
-	uint8 idcount;
-	bool wagover;
-	uint8 cidcount;
-	int c, i;
 	if (!check_length(len, 6, "FeatureMapSpriteGroup")) return;
-	feature = buf[1];
-	idcount = buf[2] & 0x7F;
+	uint8 feature = buf[1];
-	wagover = (buf[2] & 0x80) == 0x80;
+	uint8 idcount = buf[2] & 0x7F;
+	bool wagover = (buf[2] & 0x80) == 0x80;
 	if (!check_length(len, 3 + idcount, "FeatureMapSpriteGroup")) return;
-	/* If ``n-id'' (or ``idcount'') is zero, this is a ``feature
+	/* If idcount is zero, this is a feature callback */
-	 * callback''. */
 	if (idcount == 0) {
 		grfmsg(2, "FeatureMapSpriteGroup: Feature callbacks not implemented yet");
 		return;
 	}
-	cidcount = buf[3 + idcount];
+	uint8 cidcount = buf[3 + idcount];
 	if (!check_length(len, 4 + idcount + cidcount * 3, "FeatureMapSpriteGroup")) return;
 	grfmsg(6, "FeatureMapSpriteGroup: Feature %d, %d ids, %d cids, wagon override %d",
 			feature, idcount, cidcount, wagover);
 	if (feature == GSF_STATION) {
 		// We do things differently for stations.
-		for (i = 0; i < idcount; i++) {
+		for (uint i = 0; i < idcount; i++) {
 			uint8 stid = buf[3 + i];
 			StationSpec *statspec = _cur_grffile->stations[stid];
 			byte *bp = &buf[4 + idcount];
-			for (c = 0; c < cidcount; c++) {
+			for (uint c = 0; c < cidcount; c++) {
 				uint8 ctype = grf_load_byte(&bp);
 				uint16 groupid = grf_load_word(&bp);
 				if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
 					grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
 				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping",
 				       groupid, _cur_grffile->spritegroups_count);
 				return;
 			}
-			for (i = 0; i < idcount; i++) {
+			for (uint i = 0; i < idcount; i++) {
 				uint8 stid = buf[3 + i];
 				StationSpec *statspec = _cur_grffile->stations[stid];
 				statspec->spritegroup[CT_DEFAULT] = _cur_grffile->spritegroups[groupid];
 				statspec->grfid = _cur_grffile->grfid;
 		grfmsg(6, "FeatureMapSpriteGroup: WagonOverride: %u engines, %u wagons",
 				last_engines_count, idcount);
 	}
-	for (i = 0; i < idcount; i++) {
+	for (uint i = 0; i < idcount; i++) {
 		uint8 engine_id = buf[3 + i];
 		uint8 engine = engine_id + _vehshifts[feature];
 		byte *bp = &buf[4 + idcount];
 		if (engine_id > _vehcounts[feature]) {
 			return;
 		}
 		grfmsg(7, "FeatureMapSpriteGroup: [%d] Engine %d...", i, engine);
-		for (c = 0; c < cidcount; c++) {
+		for (uint c = 0; c < cidcount; c++) {
 			uint8 ctype = grf_load_byte(&bp);
 			uint16 groupid = grf_load_word(&bp);
 			grfmsg(8, "FeatureMapSpriteGroup: * [%d] Cargo type 0x%X, group id 0x%02X", c, ctype, groupid);
 		byte *bp = buf + 4 + idcount + cidcount * 3;
 		uint16 groupid = grf_load_word(&bp);
 		grfmsg(8, "-- Default group id 0x%04X", groupid);
-		for (i = 0; i < idcount; i++) {
+		for (uint i = 0; i < idcount; i++) {
 			uint8 engine = buf[3 + i] + _vehshifts[feature];
 			// Don't tell me you don't love duplicated code!
 			if (groupid >= _cur_grffile->spritegroups_count || _cur_grffile->spritegroups[groupid] == NULL) {
 				grfmsg(1, "FeatureMapSpriteGroup: Spriteset 0x%04X out of range 0x%X or empty, skipping", groupid, _cur_grffile->spritegroups_count);
 	 * B/W offset      number of the first vehicle that gets a new name
 	 *                 Byte : ID of vehicle to change
 	 *                 Word : ID of string to change/add
 	 * S data          new texts, each of them zero-terminated, after
 	 *                 which the next name begins. */
-	/* TODO: No support for changing non-vehicle text. Perhaps we shouldn't
-	 * implement it at all, but it could be useful for some "modpacks"
-	 * (completely new scenarios changing all graphics and logically also
-	 * factory names etc). We should then also support all languages (by
-	 * name), not only the original four ones. --pasky
-	 * All of the above are coming.  In Time.  Some sooner than others :)*/
-	uint8 feature;
-	uint8 lang;
-	uint8 num;
-	uint16 id;
-	uint16 endid;
 	bool new_scheme = _cur_grffile->grf_version >= 7;
-	bool generic;
 	if (!check_length(len, 6, "FeatureNewName")) return;
 	buf++;
-	feature  = grf_load_byte(&buf);
+	uint8 feature  = grf_load_byte(&buf);
-	lang     = grf_load_byte(&buf);
+	uint8 lang     = grf_load_byte(&buf);
-	num      = grf_load_byte(&buf);
+	uint8 num      = grf_load_byte(&buf);
-	generic  = HASBIT(lang, 7);
+	bool generic   = HASBIT(lang, 7);
-	id       = generic ? grf_load_word(&buf) : grf_load_byte(&buf);
+	uint16 id      = generic ? grf_load_word(&buf) : grf_load_byte(&buf);
 	CLRBIT(lang, 7);
 	if (feature <= GSF_AIRCRAFT && id < _vehcounts[feature]) {
 		id += _vehshifts[feature];
 	}
-	endid    = id + num;
+	uint16 endid = id + num;
 	grfmsg(6, "FeatureNewName: About to rename engines %d..%d (feature %d) in language 0x%02X",
 	               id, endid, feature, lang);
 	len -= generic ? 6 : 5;
 	 * B graphics-type What set of graphics the sprites define.
 	 * E num-sprites   How many sprites are in this set?
 	 * V other data    Graphics type specific data.  Currently unused. */
 	/* TODO */
-	uint8 type;
-	uint16 num;
 	SpriteID replace = 0;
 	if (!check_length(len, 2, "GraphicsNew")) return;
 	buf++;
-	type = grf_load_byte(&buf);
+	uint8 type = grf_load_byte(&buf);
-	num  = grf_load_extended(&buf);
+	uint16 num = grf_load_extended(&buf);
 	switch (type) {
 		case 0x04: /* Signal graphics */
 			if (num != 112 && num != 240) {
 				grfmsg(1, "GraphicsNews: Signal graphics sprite count must be 112 or 240, skipping");
 	 * B param-size
 	 * B condition-type
 	 * V value
 	 * B num-sprites */
 	/* TODO: More params. More condition types. */
-	uint8 param;
-	uint8 paramsize;
-	uint8 condtype;
-	uint8 numsprites;
-	uint32 param_val = 0;
 	uint32 cond_val = 0;
 	uint32 mask = 0;
 	bool result;
-	GRFLabel *label;
-	GRFLabel *choice = NULL;
 	if (!check_length(len, 6, "SkipIf")) return;
 	buf++;
-	param     = grf_load_byte(&buf);
+	uint8 param     = grf_load_byte(&buf);
-	paramsize = grf_load_byte(&buf);
+	uint8 paramsize = grf_load_byte(&buf);
-	condtype  = grf_load_byte(&buf);
+	uint8 condtype  = grf_load_byte(&buf);
 	if (condtype < 2) {
 		/* Always 1 for bit tests, the given value should be ignored. */
 		paramsize = 1;
 	}
 	if (param < 0x80 && _cur_grffile->param_end <= param) {
 		grfmsg(7, "Param %d undefined, skipping test", param);
 		return;
 	}
-	param_val = GetParamVal(param, &cond_val);
+	uint32 param_val = GetParamVal(param, &cond_val);
 	grfmsg(7, "Test condtype %d, param 0x%08X, condval 0x%08X", condtype, param_val, cond_val);
 	if (param == 0x88) {
 		/* GRF ID checks */
 	if (!result) {
 		grfmsg(2, "Not skipping sprites, test was false");
 		return;
 	}
-	numsprites = grf_load_byte(&buf);
+	uint8 numsprites = grf_load_byte(&buf);
 	/* numsprites can be a GOTO label if it has been defined in the GRF
 	 * file. The jump will always be the first matching label that follows
 	 * the current nfo_line. If no matching label is found, the first matching
 	 * label in the file is used. */
-	for (label = _cur_grffile->label; label != NULL; label = label->next) {
+	GRFLabel *choice = NULL;
+	for (GRFLabel *label = _cur_grffile->label; label != NULL; label = label->next) {
 		if (label->label != numsprites) continue;
 		/* Remember a goto before the current line */
 		if (choice == NULL) choice = label;
 		/* If we find a label here, this is definitely good */
 /* Action 0x08 (GLS_FILESCAN) */
 static void ScanInfo(byte *buf, int len)
 {
-	uint8 version;
+	if (!check_length(len, 8, "Info")) return;
-	uint32 grfid;
+	buf++;
-	const char *name;
+	grf_load_byte(&buf);
-	const char *info;
+	uint32 grfid  = grf_load_dword(&buf);
-	if (!check_length(len, 8, "Info")) return; buf++;
-	version = grf_load_byte(&buf);
-	grfid = grf_load_dword(&buf);
 	_cur_grfconfig->grfid = grfid;
 	/* GRF IDs starting with 0xFF are reserved for internal TTDPatch use */
 	if (GB(grfid, 24, 8) == 0xFF) SETBIT(_cur_grfconfig->flags, GCF_SYSTEM);
 	len -= 6;
-	name = grf_load_string(&buf, len);
+	const char *name = grf_load_string(&buf, len);
 	_cur_grfconfig->name = TranslateTTDPatchCodes(name);
 	len -= strlen(name) + 1;
 	if (len > 0) {
-		info = grf_load_string(&buf, len);
+		const char *info = grf_load_string(&buf, len);
 		_cur_grfconfig->info = TranslateTTDPatchCodes(info);
 	}
 	/* GLS_INFOSCAN only looks for the action 8, so we can skip the rest of the file */
 	_skip_sprites = -1;
 	 *
 	 * B version       newgrf version, currently 06
 	 * 4*B grf-id      globally unique ID of this .grf file
 	 * S name          name of this .grf set
 	 * S info          string describing the set, and e.g. author and copyright */
-	/* TODO: Check version. (We should have own versioning done somehow.) */
-	uint8 version;
+	if (!check_length(len, 8, "GRFInfo")) return;
-	uint32 grfid;
+	buf++;
-	const char *name;
+	uint8 version    = grf_load_byte(&buf);
+	uint32 grfid     = grf_load_dword(&buf);
-	if (!check_length(len, 8, "GRFInfo")) return; buf++;
+	const char *name = grf_load_string(&buf, len - 6);
-	version = grf_load_byte(&buf);
-	grfid = grf_load_dword(&buf);
-	name = grf_load_string(&buf, len - 6);
 	_cur_grffile->grfid = grfid;
 	_cur_grffile->grf_version = version;
 	_cur_grfconfig->status = _cur_stage < GLS_ACTIVATION ? GCS_INITIALISED : GCS_ACTIVATED;
 	 *
 	 * B num-sets      How many sets of sprites to replace.
 	 * Each set:
 	 * B num-sprites   How many sprites are in this set
 	 * W first-sprite  First sprite number to replace */
-	uint8 num_sets;
-	uint i;
 	buf++; /* skip action byte */
-	num_sets = grf_load_byte(&buf);
+	uint8 num_sets = grf_load_byte(&buf);
-	for (i = 0; i < num_sets; i++) {
+	for (uint i = 0; i < num_sets; i++) {
 		uint8 num_sprites = grf_load_byte(&buf);
 		uint16 first_sprite = grf_load_word(&buf);
-		uint j;
 		grfmsg(2, "SpriteReplace: [Set %d] Changing %d sprites, beginning with %d",
 			i, num_sprites, first_sprite
 		);
-		for (j = 0; j < num_sprites; j++) {
+		for (uint j = 0; j < num_sprites; j++) {
 			LoadNextSprite(first_sprite + j, _file_index); // XXX
 			_nfo_line++;
 		}
 	}
 }
 }
 /* Action 0x0D (GLS_SAFETYSCAN) */
 static void SafeParamSet(byte *buf, int len)
 {
-	uint8 target;
 	if (!check_length(len, 5, "SafeParamSet")) return;
 	buf++;
-	target = grf_load_byte(&buf);
+	uint8 target = grf_load_byte(&buf);
 	/* Only writing GRF parameters is considered safe */
 	if (target < 0x80) return;
 	/* GRM could be unsafe, but as here it can only happen after other GRFs
 	 *         negative, source1 is unsigned)
 	 * 06      Signed bit shift, source1 by source2
 	 *         (source2 like in 05, and source1 as well)
 	 */
-	byte target;
-	byte oper;
-	uint32 src1;
-	uint32 src2;
-	uint32 data = 0;
-	uint32 res;
 	if (!check_length(len, 5, "ParamSet")) return;
 	buf++;
-	target = grf_load_byte(&buf);
+	uint8 target = grf_load_byte(&buf);
-	oper = grf_load_byte(&buf);
+	uint8 oper   = grf_load_byte(&buf);
-	src1 = grf_load_byte(&buf);
+	uint32 src1  = grf_load_byte(&buf);
-	src2 = grf_load_byte(&buf);
+	uint32 src2  = grf_load_byte(&buf);
+	uint32 data = 0;
 	if (len >= 8) data = grf_load_dword(&buf);
 	/* You can add 80 to the operation to make it apply only if the target
 	 * is not defined yet.  In this respect, a parameter is taken to be
 	 * defined if any of the following applies:
 	 * - it has been set to any value in the newgrf(w).cfg parameter list
 	 * - it OR A PARAMETER WITH HIGHER NUMBER has been set to any value by
 	 *   an earlier action D */
-	if (oper & 0x80) {
+	if (HASBIT(oper, 7)) {
 		if (target < 0x80 && target < _cur_grffile->param_end) {
 			grfmsg(7, "Param %u already defined, skipping", target);
 			return;
 		}
-		oper &= 0x7F;
+		oper = GB(oper, 0, 7);
 	}
 	if (src2 == 0xFE) {
 		if (GB(data, 0, 8) == 0xFF) {
 			if (data == 0x0000FFFF) {
 						case 0x03: /* Aircraft */
 						{
 							uint start = 0;
 							uint size  = 0;
 							uint shift = _vehshifts[feature];
-							int i;
 							if (op == 6) {
 								/* Return GRFID of set that reserved ID */
 								src1 = _grm_engines[shift + _cur_grffile->param[target]];
 								break;
 							}
 							/* With an operation of 2 or 3, we want to reserve a specific block of IDs */
 							if (op == 2 || op == 3) start = _cur_grffile->param[target];
-							for (i = start; i < _vehcounts[feature]; i++) {
+							for (uint i = start; i < _vehcounts[feature]; i++) {
 								if (_grm_engines[shift + i] == 0) {
 									size++;
 								} else {
 									if (op == 2 || op == 3) break;
 									start = i + 1;
 							if (size == count) {
 								/* Got the slot... */
 								if (op == 0 || op == 3) {
 									grfmsg(2, "GRM: Reserving %d vehicles at %d", count, start);
-									for (i = 0; i < count; i++) _grm_engines[shift + start + i] = _cur_grffile->grfid;
+									for (uint i = 0; i < count; i++) _grm_engines[shift + start + i] = _cur_grffile->grfid;
 								}
 								src1 = start;
 							} else {
 								/* Unable to allocate */
 								if (op != 4 && op != 5) {
 	 * source2=FE, source1=the other GRF's parameter number and data=GRF
 	 * ID.  This is only valid with operation 00 (set).  If the GRF ID
 	 * cannot be found, a value of 0 is used for the parameter value
 	 * instead. */
+	uint32 res;
 	switch (oper) {
 		case 0x00:
 			res = src1;
 			break;
 	/* <0E> <num> <grfids...>
 	 *
 	 * B num           Number of GRFIDs that follow
 	 * D grfids        GRFIDs of the files to deactivate */
-	byte num;
+	if (!check_length(len, 2, "GRFInhibit")) return;
-	int i;
+	buf++;
+	uint8 num = grf_load_byte(&buf);
-	if (!check_length(len, 1, "GRFInhibit")) return;
+	if (!check_length(len, 2 + 4 * num, "GRFInhibit")) return;
-	buf++, len--;
-	num = grf_load_byte(&buf); len--;
+	for (uint i = 0; i < num; i++) {
-	if (!check_length(len, 4 * num, "GRFInhibit")) return;
-	for (i = 0; i < num; i++) {
 		uint32 grfid = grf_load_dword(&buf);
 		/* GRF is unsafe it if tries to deactivate other GRFs */
 		if (grfid != _cur_grfconfig->grfid) {
 			SETBIT(_cur_grfconfig->flags, GCF_UNSAFE);
 	/* <0E> <num> <grfids...>
 	 *
 	 * B num           Number of GRFIDs that follow
 	 * D grfids        GRFIDs of the files to deactivate */
-	byte num;
+	if (!check_length(len, 2, "GRFInhibit")) return;
-	int i;
+	buf++;
+	uint8 num = grf_load_byte(&buf);
-	if (!check_length(len, 1, "GRFInhibit")) return;
+	if (!check_length(len, 2 + 4 * num, "GRFInhibit")) return;
-	buf++, len--;
-	num = grf_load_byte(&buf); len--;
+	for (uint i = 0; i < num; i++) {
-	if (!check_length(len, 4 * num, "GRFInhibit")) return;
-	for (i = 0; i < num; i++) {
 		uint32 grfid = grf_load_dword(&buf);
 		GRFConfig *file = GetGRFConfig(grfid);
 		/* Unset activation flag */
 		if (file != NULL && file != _cur_grfconfig) {
 	/* <10> <label> [<comment>]
 	 *
 	 * B label      The label to define
 	 * V comment    Optional comment - ignored */
-	GRFLabel *label;
 	if (!check_length(len, 1, "DefineGotoLabel")) return;
 	buf++; len--;
-	label = MallocT<GRFLabel>(1);
+	GRFLabel *label = MallocT<GRFLabel>(1);
 	label->label    = grf_load_byte(&buf);
 	label->nfo_line = _nfo_line;
 	label->pos      = FioGetPos();
 	label->next     = NULL;
 {
 	/* <11> <num>
 	 *
 	 * W num      Number of sound files that follow */
-	uint16 num;
 	if (!check_length(len, 1, "GRFSound")) return;
 	buf++;
-	num = grf_load_word(&buf);
+	uint16 num = grf_load_word(&buf);
 	_grf_data_blocks = num;
 	_grf_data_type   = GDT_SOUND;
 	if (_cur_grffile->sound_offset == 0) _cur_grffile->sound_offset = GetNumSounds();
 }
 static void LoadGRFSound(byte *buf, int len)
 {
 	byte *buf_start = buf;
-	FileEntry *se;
 	/* Allocate a sound entry. This is done even if the data is not loaded
 	 * so that the indices used elsewhere are still correct. */
-	se = AllocateFileEntry();
+	FileEntry *se = AllocateFileEntry();
 	if (grf_load_dword(&buf) != BSWAP32('RIFF')) {
 		grfmsg(1, "LoadGRFSound: Missing RIFF header");
 		return;
 	}
 	 * B num_def      Number of definitions
 	 * B font_size    Size of font (0 = normal, 1 = small, 2 = large)
 	 * B num_char     Number of consecutive glyphs
 	 * W base_char    First character index */
-	uint8 num_def;
-	uint i;
 	buf++; len--;
 	if (!check_length(len, 1, "LoadFontGlyph")) return;
-	num_def = grf_load_byte(&buf);
+	uint8 num_def = grf_load_byte(&buf);
 	if (!check_length(len, 1 + num_def * 4, "LoadFontGlyph")) return;
-	for (i = 0; i < num_def; i++) {
+	for (uint i = 0; i < num_def; i++) {
 		FontSize size    = (FontSize)grf_load_byte(&buf);
 		uint8  num_char  = grf_load_byte(&buf);
 		uint16 base_char = grf_load_word(&buf);
-		uint c;
 		grfmsg(7, "LoadFontGlyph: Loading %u glyph(s) at 0x%04X for size %u", num_char, base_char, size);
-		for (c = 0; c < num_char; c++) {
+		for (uint c = 0; c < num_char; c++) {
 			SetUnicodeGlyph(size, base_char + c, _cur_spriteid);
 			LoadNextSprite(_cur_spriteid++, _file_index);
 			_nfo_line++;
 		}
 	}
 }
 /* 'Action 0xFF' */
 static void GRFDataBlock(byte *buf, int len)
 {
-	byte name_len;
-	const char *name;
 	if (_grf_data_blocks == 0) {
 		grfmsg(2, "GRFDataBlock: unexpected data block, skipping");
 		return;
 	}
 	buf++;
-	name_len = grf_load_byte(&buf);
+	uint8 name_len = grf_load_byte(&buf);
-	name = (const char *)buf;
+	const char *name = (const char *)buf;
 	buf += name_len + 1;
 	grfmsg(2, "GRFDataBlock: block name '%s'...", name);
 	_grf_data_blocks--;
 	                   |                                        (0 << 0x17); // articulatedrvs
 }
 static void ResetCustomStations()
 {
-	StationSpec *statspec;
+	for (GRFFile *file = _first_grffile; file != NULL; file = file->next) {
-	GRFFile *file;
-	uint i;
-	uint t;
-	for (file = _first_grffile; file != NULL; file = file->next) {
 		if (file->stations == NULL) continue;
-		for (i = 0; i < MAX_STATIONS; i++) {
+		for (uint i = 0; i < MAX_STATIONS; i++) {
 			if (file->stations[i] == NULL) continue;
-			statspec = file->stations[i];
+			StationSpec *statspec = file->stations[i];
 			/* Release renderdata, if it wasn't copied from another custom station spec  */
 			if (!statspec->copied_renderdata) {
-				for (t = 0; t < statspec->tiles; t++) {
+				for (uint t = 0; t < statspec->tiles; t++) {
 					free((void*)statspec->renderdata[t].seq);
 				}
 				free(statspec->renderdata);
 			}
 			/* Release platforms and layouts */
 			if (!statspec->copied_layouts) {
-				uint l, p;
+				for (uint l = 0; l < statspec->lengths; l++) {
-				for (l = 0; l < statspec->lengths; l++) {
+					for (uint p = 0; p < statspec->platforms[l]; p++) {
-					for (p = 0; p < statspec->platforms[l]; p++) {
 						free(statspec->layouts[l][p]);
 					}
 					free(statspec->layouts[l]);
 				}
 				free(statspec->layouts);
 	}
 }
 static void ResetNewGRF()
 {
-	GRFFile *f, *next;
+	GRFFile *next;
-	for (f = _first_grffile; f != NULL; f = next) {
+	for (GRFFile *f = _first_grffile; f != NULL; f = next) {
 		next = f->next;
 		free(f->filename);
 		free(f);
 	}
 * Reset all NewGRF loaded data
 * TODO
 */
 static void ResetNewGRFData()
 {
-	uint i;
 	CleanUpStrings();
 	// Copy/reset original engine info data
 	memcpy(&_engine_info, &orig_engine_info, sizeof(orig_engine_info));
 	memcpy(&_rail_vehicle_info, &orig_rail_vehicle_info, sizeof(orig_rail_vehicle_info));
 	memcpy(&_aircraft_vehicle_info, &orig_aircraft_vehicle_info, sizeof(orig_aircraft_vehicle_info));
 	memcpy(&_road_vehicle_info, &orig_road_vehicle_info, sizeof(orig_road_vehicle_info));
 	// Copy/reset original bridge info data
 	// First, free sprite table data
-	for (i = 0; i < MAX_BRIDGES; i++) {
+	for (uint i = 0; i < MAX_BRIDGES; i++) {
 		if (_bridge[i].sprite_table != NULL) {
-			uint j;
+			for (uint j = 0; j < 7; j++) free(_bridge[i].sprite_table[j]);
-			for (j = 0; j < 7; j++) free(_bridge[i].sprite_table[j]);
 			free(_bridge[i].sprite_table);
 		}
 	}
 	memcpy(&_bridge, &orig_bridge, sizeof(_bridge));
 /** Reset all NewGRFData that was used only while processing data */
 static void ClearTemporaryNewGRFData()
 {
 	/* Clear the GOTO labels used for GRF processing */
-	GRFLabel *l;
+	for (GRFLabel *l = _cur_grffile->label; l != NULL;) {
-	for (l = _cur_grffile->label; l != NULL;) {
 		GRFLabel *l2 = l->next;
 		free(l);
 		l = l2;
 	}
 	_cur_grffile->label = NULL;
 	}
 }
 static void InitNewGRFFile(const GRFConfig *config, int sprite_offset)
 {
-	GRFFile *newfile;
+	GRFFile *newfile = GetFileByFilename(config->filename);
-	newfile = GetFileByFilename(config->filename);
 	if (newfile != NULL) {
 		/* We already loaded it once. */
 		newfile->sprite_offset = sprite_offset;
 		_cur_grffile = newfile;
 		return;
 /**
 * Precalculate refit masks from cargo classes for all vehicles.
 */
 static void CalculateRefitMasks()
 {
-	EngineID engine;
+	for (EngineID engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {
-	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {
 		uint32 mask = 0;
 		uint32 not_mask = 0;
 		uint32 xor_mask = _engine_info[engine].refit_mask;
-		byte i;
 		if (cargo_allowed[engine] != 0) {
 			// Build up the list of cargo types from the set cargo classes.
-			for (i = 0; i < NUM_CARGO; i++) {
+			for (CargoID i = 0; i < NUM_CARGO; i++) {
 				const CargoSpec *cs = GetCargo(i);
 				if (cargo_allowed[engine]    & cs->classes) SETBIT(mask,     i);
 				if (cargo_disallowed[engine] & cs->classes) SETBIT(not_mask, i);
 			}
 		} else {
 		/* 0x12 */ { NULL,     NULL,      NULL,            NULL,       LoadFontGlyph, },
 		/* 0x13 */ { NULL,     NULL,      NULL,            NULL,       TranslateGRFStrings, },
 	};
 	byte* buf;
-	byte action;
 	if (_preload_sprite == NULL) {
 		/* No preloaded sprite to work with; allocate and read the
 		 * pseudo sprite content. */
 		buf = MallocT<byte>(num);
 		/* Skip the real (original) content of this action. */
 		FioSeekTo(num, SEEK_CUR);
 	}
-	action = buf[0];
+	byte action = buf[0];
 	if (action == 0xFF) {
 		grfmsg(7, "Handling data block in stage %d", stage);
 		GRFDataBlock(buf, num);
 	} else if (action == 0xFE) {
 void InitDepotWindowBlockSizes();
 void LoadNewGRF(uint load_index, uint file_index)
 {
-	GrfLoadingStage stage;
 	InitializeGRFSpecial();
 	ResetNewGRFData();
 	/* Load newgrf sprites
 	 * in each loading stage, (try to) open each file specified in the config
 	 * and load information from it. */
-	for (stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
+	for (GrfLoadingStage stage = GLS_LABELSCAN; stage <= GLS_ACTIVATION; stage++) {
 		uint slot = file_index;
-		GRFConfig *c;
 		_cur_stage = stage;
 		_cur_spriteid = load_index;
-		for (c = _grfconfig; c != NULL; c = c->next) {
+		for (GRFConfig *c = _grfconfig; c != NULL; c = c->next) {
 			if (c->status == GCS_DISABLED || c->status == GCS_NOT_FOUND) continue;
 			// TODO usererror()
 			if (!FioCheckFileExists(c->filename)) error("NewGRF file is missing '%s'", c->filename);
 	CalculateRefitMasks();
 	/* Set the block size in the depot windows based on vehicle sprite sizes */
 	InitDepotWindowBlockSizes();
 }

changeset 6607	b4f6595855c4
parent 6606	2e867a1c6b7f
child 6608	80bc656cc6fb