if [ "$cc_version" = "10.1" ]; then

			CFLAGS="$CFLAGS -Wno-multichar"

		fi

	else

		# Enable some things only for certain GCC versions

		cc_version=`$cc_host -dumpversion | cut -c 1,3`

		if [ $cc_version -ge 29 ]; then

			CFLAGS="$CFLAGS -Wall -Wno-multichar -Wsign-compare -Wundef"

			CFLAGS="$CFLAGS -Wwrite-strings -Wpointer-arith"

			CC_CFLAGS="$CC_CFLAGS -Wstrict-prototypes"

		fi

		gcc295=""

		if [ "$cc_version" = 29 ]; then

			# Make sure we mark GCC 2.95 flag for Makefile.src.in, as we

			#  need a lovely hack there to make it compile correctly.

			gcc295="1"

		fi

		if [ $cc_version -ge 30 ]; then

#include "functions.h"

#include "window_func.h"

#include "date_func.h"

#include "vehicle_func.h"

#include "sound_func.h"

#include "track_type.h"

#include "track_func.h"

#include "road_func.h"

#include "rail_map.h"

#include "signal_func.h"

#include "gfx_func.h"

#include "autoreplace_func.h"

#include "table/strings.h"

#include "table/sprites.h"

/**

 * Multiply two integer values and shift the results to right.

 *

 * This function multiplies two integer values. The result is

 * shifted by the amount of shift to right.

 *

 * @param a The first integer

 * @param b The second integer

void ShowCostOrIncomeAnimation(int x, int y, int z, Money cost);

void ShowFeederIncomeAnimation(int x, int y, int z, Money cost);

void ShowHighscoreTable(int difficulty, int8 rank);

void AskExitGame();

void AskExitToGameMenu();

void RedrawAutosave();

void UpdateViewportSignPos(ViewportSign *sign, int left, int top, StringID str);

int ttd_main(int argc, char* argv[]);

void HandleExitGameRequest();

#endif /* FUNCTIONS_H */

extern int _pal_count_dirty;

extern int _num_resolutions;

extern uint16 _resolutions[32][2];

extern uint16 _cur_resolution[2];

extern Colour _cur_palette[256];

void HandleKeypress(uint32 key);

void HandleCtrlChanged();

void HandleMouseEvents();

void CSleep(int milliseconds);

void UpdateWindows();

void DrawMouseCursor();

void ScreenSizeChanged();

void GameSizeChanged();

void UndrawMouseCursor();

void RedrawScreenRect(int left, int top, int right, int bottom);

void GfxScroll(int left, int top, int width, int height, int xo, int yo);

void DrawSprite(SpriteID img, SpriteID pal, int x, int y, const SubSprite *sub = NULL);

int DrawStringCentered(int x, int y, StringID str, uint16 color);

int DrawStringCenteredTruncated(int xl, int xr, int y, StringID str, uint16 color);

int DoDrawStringCentered(int x, int y, const char *str, uint16 color);

void MarkWholeScreenDirty();

void GfxInitPalettes();

bool FillDrawPixelInfo(DrawPixelInfo* n, int left, int top, int width, int height);

/* window.cpp */

void DrawOverlappedWindowForAll(int left, int top, int right, int bottom);

void SetMouseCursor(SpriteID sprite, SpriteID pal);

void SetAnimatedMouseCursor(const AnimCursor *table);

void CursorTick();

bool ChangeResInGame(int w, int h);

void SortResolutions(int count);

bool ToggleFullScreen(bool fs);

/* gfx.cpp */

#define ASCII_LETTERSTART 32

extern FontSize _cur_fontsize;

byte GetCharacterWidth(FontSize size, uint32 key);

static inline byte GetCharacterHeight(FontSize size)

{

	DDSP_PLACE_AUTORAIL,

	DDSP_BUILD_SIGNALS,

	DDSP_BUILD_STATION,

	DDSP_REMOVE_STATION,

	DDSP_CONVERT_RAIL,

	/* Road specific actions */

	DDSP_PLACE_ROAD_X_DIR,

	DDSP_PLACE_ROAD_Y_DIR,

	DDSP_PLACE_AUTOROAD,

};

/* misc_gui.cpp */

void PlaceLandBlockInfo();

void ShowAboutWindow();

void ShowBuildTreesToolbar();

void ShowBuildTreesScenToolbar();

void ShowTownDirectory();

void ShowIndustryDirectory();

void ShowSubsidiesList();

void ShowEstimatedCostOrIncome(Money cost, int x, int y);

void ShowErrorMessage(StringID msg_1, StringID msg_2, int x, int y);

#include "textbuf_gui.h"

#include "network/network.h"

#include "variables.h"

#include "heightmap.h"

#include "genworld.h"

#include "network/network_gui.h"

#include "newgrf.h"

#include "strings_func.h"

#include "window_func.h"

#include "fios.h"

#include "gfx_func.h"

#include "settings_type.h"

#include "table/strings.h"

#include "table/sprites.h"

static const Widget _select_game_widgets[] = {

{    WWT_CAPTION, RESIZE_NONE, 13,   0, 335,   0,  13, STR_0307_OPENTTD,         STR_NULL},

{      WWT_PANEL, RESIZE_NONE, 13,   0, 335,  14, 194, 0x0,                      STR_NULL},

{ WWT_PUSHTXTBTN, RESIZE_NONE, 12,  10, 167,  22,  33, STR_0140_NEW_GAME,        STR_02FB_START_A_NEW_GAME},

{ WWT_PUSHTXTBTN, RESIZE_NONE, 12, 168, 325,  22,  33, STR_0141_LOAD_GAME,       STR_02FC_LOAD_A_SAVED_GAME},

{ WWT_PUSHTXTBTN, RESIZE_NONE, 12,  10, 167,  40,  51, STR_029A_PLAY_SCENARIO,   STR_0303_START_A_NEW_GAME_USING},

{ WWT_PUSHTXTBTN, RESIZE_NONE, 12, 168, 325,  40,  51, STR_PLAY_HEIGHTMAP,       STR_PLAY_HEIGHTMAP_HINT},

{ WWT_PUSHTXTBTN, RESIZE_NONE, 12,  10, 167,  58,  69, STR_SCENARIO_EDITOR,      STR_02FE_CREATE_A_CUSTOMIZED_GAME},

	Player *p;

	if (_game_mode == GM_EDITOR) return;

	p = GetPlayer((PlayerID)_cur_player_tick_index);

	_cur_player_tick_index = (_cur_player_tick_index + 1) % MAX_PLAYERS;

	if (p->name_1 != 0) GenerateCompanyName(p);

	if (AI_AllowNewAI() && _game_mode != GM_MENU && !--_next_competitor_start)

		MaybeStartNewPlayer();

}

void PlayersYearlyLoop()

{

	Player *p;

	/* Copy statistics */

	FOR_ALL_PLAYERS(p) {

		if (p->is_active) {

			memmove(&p->yearly_expenses[1], &p->yearly_expenses[0], sizeof(p->yearly_expenses) - sizeof(p->yearly_expenses[0]));

			memset(&p->yearly_expenses[0], 0, sizeof(p->yearly_expenses[0]));

			InvalidateWindow(WC_FINANCES, p->index);

		}

	}

#include "gfx_func.h"

#include "player_base.h"

#include "town.h"

#include "variables.h"

#include "blitter/factory.hpp"

#include "tunnelbridge_map.h"

#include "strings_func.h"

#include "zoom_func.h"

#include "core/endian_func.hpp"

#include "vehicle_base.h"

#include "sound_func.h"

#include "settings_type.h"

#include "table/strings.h"

#include "table/sprites.h"

static const Widget _smallmap_widgets[] = {

{  WWT_CLOSEBOX,   RESIZE_NONE,    13,     0,    10,     0,    13, STR_00C5,                STR_018B_CLOSE_WINDOW},

{   WWT_CAPTION,  RESIZE_RIGHT,    13,    11,   337,     0,    13, STR_00B0_MAP,            STR_018C_WINDOW_TITLE_DRAG_THIS},

{ WWT_STICKYBOX,     RESIZE_LR,    13,   338,   349,     0,    13, 0x0,                     STR_STICKY_BUTTON},

{     WWT_PANEL,     RESIZE_RB,    13,     0,   349,    14,   157, 0x0,                     STR_NULL},

{     WWT_INSET,     RESIZE_RB,    13,     2,   347,    16,   155, 0x0,                     STR_NULL},

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   284,   305,   158,   179, SPR_IMG_SHOW_COUNTOURS,  STR_0191_SHOW_LAND_CONTOURS_ON_MAP},

{    WWT_IMGBTN,   RESIZE_LRTB,    13,   306,   327,   158,   179, SPR_IMG_SHOW_VEHICLES,   STR_0192_SHOW_VEHICLES_ON_MAP},

#include "date_func.h"

#include "gfx_func.h"

#include "news_func.h"

#include "player_func.h"

#include "string_func.h"

#include "strings_func.h"

#include "player_base.h"

#include "viewport_func.h"

#include "news_gui.h"

#include "player_gui.h"

#include "window_gui.h"

#include "variables.h"

#include "table/strings.h"

#include "table/sprites.h"

extern GetNewsStringCallbackProc * const _get_news_string_callback[];

static bool DrawScrollingStatusText(const NewsItem *ni, int pos, int width)

{

	StringID str;

	if (ni->display_mode == NM_CALLBACK) {

		str = _get_news_string_callback[ni->callback](ni);

	} else {

	typedef unsigned __int64 uint64;

	typedef   signed __int64  int64;

#endif /* !__BEOS__ && !__NDS__ */

#if !defined(WITH_PERSONAL_DIR)

	#define PERSONAL_DIR ""

#endif

/* Compile time assertions */

#if defined(__OS2__)

	#define assert_compile(expr)

#else

#endif /* __OS2__ */

/* Check if the types have the bitsizes like we are using them */

assert_compile(sizeof(uint64) == 8);

assert_compile(sizeof(uint32) == 4);

assert_compile(sizeof(uint16) == 2);

assert_compile(sizeof(uint8)  == 1);

#define endof(x) (&x[lengthof(x)])

#define lastof(x) (&x[lengthof(x) - 1])

#define cpp_offsetof(s, m)   (((size_t)&reinterpret_cast<const volatile char&>((((s*)(char*)8)->m))) - 8)

#if !defined(offsetof)

	#define offsetof(s, m) cpp_offsetof(s, m)

#endif /* offsetof */

/* take care of some name clashes on MacOS */

#if defined(__APPLE__)

	#define GetString OTTD_GetString

{

	assert(v->type == VEH_TRAIN);

	v = GetNextVehicle(v);

	if (v != NULL && IsRearDualheaded(v)) v = v->Next();

	return v;

}

void ConvertOldMultiheadToNew();

void ConnectMultiheadedTrains();

uint CountArticulatedParts(EngineID engine_type);

void CcBuildLoco(bool success, TileIndex tile, uint32 p1, uint32 p2);

void CcBuildWagon(bool success, TileIndex tile, uint32 p1, uint32 p2);

byte FreightWagonMult(CargoID cargo);

int CheckTrainInDepot(const Vehicle *v, bool needs_to_be_stopped);

int CheckTrainStoppedInDepot(const Vehicle *v);

void UpdateTrainAcceleration(Vehicle* v);

/**

 * This class 'wraps' Vehicle; you do not actually instantiate this class.

 * You create a Vehicle using AllocateVehicle, so it is added to the pool

#include "group.h"

#include "group_gui.h"

#include "strings_func.h"

#include "functions.h"

#include "window_func.h"

#include "vehicle_func.h"

#include "autoreplace_gui.h"

#include "core/alloc_func.hpp"

#include "string_func.h"

#include "settings_type.h"

#include "widgets/dropdown_func.h"

#include "order_func.h"

#include "table/sprites.h"

#include "table/strings.h"

struct refit_d {

	int sel;

	struct RefitOption *cargo;

	struct RefitList *list;

	uint length;

	VehicleOrderID order;

};

assert_compile(WINDOW_CUSTOM_SIZE >= sizeof(refit_d));

#include "../stdafx.h"

#include "../openttd.h"

#include "../debug.h"

#include "../gfx_func.h"

#include "../sdl.h"

#include "../variables.h"

#include "../rev.h"

#include "../blitter/factory.hpp"

#include "../network/network.h"

#include "../core/math_func.hpp"

#include "../core/random_func.hpp"

#include "sdl_v.h"

#include <SDL.h>

static FVideoDriver_SDL iFVideoDriver_SDL;

static SDL_Surface *_sdl_screen;

static bool _all_modes;

#define MAX_DIRTY_RECTS 100

static SDL_Rect _dirty_rects[MAX_DIRTY_RECTS];

static int _num_dirty_rects;

/** @file win32_v.cpp Implementation of the Windows (GDI) video driver. */

#include "../stdafx.h"

#include "../openttd.h"

#include "../gfx_func.h"

#include "../variables.h"

#include "../win32.h"

#include "../rev.h"

#include "../blitter/factory.hpp"

#include "../network/network.h"

#include "../core/math_func.hpp"

#include "../core/random_func.hpp"

#include "win32_v.h"

#include <windows.h>

#include <tchar.h>

static struct {

	HWND main_wnd;

	HBITMAP dib_sect;

	void *buffer_bits;

	HPALETTE gdi_palette;

	int width;

	int height;

	int width_org;

#include "roadveh.h"

#include "vehicle_gui.h"

#include "blitter/factory.hpp"

#include "transparency.h"

#include "strings_func.h"

#include "zoom_func.h"

#include "vehicle_func.h"

#include "player_func.h"

#include "settings_type.h"

#include "station_func.h"

#include "core/alloc_type.hpp"

#include "misc/smallvec.h"

#include "table/sprites.h"

#include "table/strings.h"

PlaceProc *_place_proc;

Point _tile_fract_coords;

ZoomLevel _saved_scrollpos_zoom;

struct StringSpriteToDraw {

	uint16 string;

	uint16 color;

	int32 x;

#include "console.h"

#include "viewport_func.h"

#include "variables.h"

#include "genworld.h"

#include "blitter/factory.hpp"

#include "window_gui.h"

#include "zoom_func.h"

#include "core/alloc_func.hpp"

#include "map_func.h"

#include "vehicle_base.h"

#include "settings_type.h"

#include "cheat_func.h"

#include "table/sprites.h"

static Point _drag_delta; ///< delta between mouse cursor and upper left corner of dragged window

static Window *_mouseover_last_w = NULL; ///< Window of the last MOUSEOVER event

/**

 * List of windows opened at the screen.

 * Uppermost window is at  _z_windows[_last_z_window - 1],

 * bottom window is at _z_windows[0]

 */

Window *_z_windows[MAX_NUMBER_OF_WINDOWS];

void ChangeWindowOwner(PlayerID old_player, PlayerID new_player);

void ResizeWindow(Window *w, int x, int y);

int PositionMainToolbar(Window *w);

void InitWindowSystem();

void UnInitWindowSystem();

void ResetWindowSystem();

void SetupColorsAndInitialWindow();

void InputLoop();

void InvalidateThisWindowData(Window *w);

void InvalidateWindowData(WindowClass cls, WindowNumber number);

void DeleteNonVitalWindows();

void DeleteAllNonVitalWindows();

void HideVitalWindows();

void ShowVitalWindows();

void InvalidateWindow(WindowClass cls, WindowNumber number);

void InvalidateWindowWidget(WindowClass cls, WindowNumber number, byte widget_index);

void InvalidateWindowClasses(WindowClass cls);

void InvalidateWindowClassesData(WindowClass cls);

void DeleteWindowById(WindowClass cls, WindowNumber number);

void DeleteWindowByClass(WindowClass cls);

	WF_DISABLE_VP_SCROLL = 1 << 10, ///< Window does not do autoscroll, @see HandleAutoscroll()

	WF_WHITE_BORDER_ONE  = 1 << 11,

	WF_WHITE_BORDER_MASK = 1 << 12 | WF_WHITE_BORDER_ONE,

	WF_SCROLL2           = 1 << 13,

};

/* window.cpp */

void CallWindowEventNP(Window *w, int event);

void CallWindowTickEvent();

Window *BringWindowToFrontById(WindowClass cls, WindowNumber number);

Window *FindWindowFromPt(int x, int y);

bool IsWindowOfPrototype(const Window *w, const Widget *widget);

void AssignWidgetToWindow(Window *w, const Widget *widget);

Window *AllocateWindow(int x, int y, int width, int height,

			WindowProc *proc, WindowClass cls, const Widget *widget,

			void *data = NULL);

Window *AllocateWindowDesc(const WindowDesc *desc, void *data = NULL);

Window *AllocateWindowDescFront(const WindowDesc *desc, int window_number, void *data = NULL);

void DrawWindowViewport(const Window *w);

int GetMenuItemIndex(const Window *w, int x, int y);

void RelocateAllWindows(int neww, int newh);

/* misc_gui.cpp */

void GuiShowTooltipsWithArgs(StringID str, uint paramcount, const uint64 params[]);

static inline void GuiShowTooltips(StringID str)

{

	GuiShowTooltipsWithArgs(str, 0, NULL);

}

/* widget.cpp */

int GetWidgetFromPos(const Window *w, int x, int y);

void DrawWindowWidgets(const Window *w);

extern bool _scrolling_viewport;

extern bool _popup_menu_active;

extern byte _special_mouse_mode;

enum SpecialMouseMode {

	WSM_NONE     = 0,

	WSM_DRAGDROP = 1,

	WSM_SIZING   = 2,

	WSM_PRESIZE  = 3,

};

Window *GetCallbackWnd();

Window **FindWindowZPosition(const Window *w);

void ScrollbarClickHandler(Window *w, const Widget *wi, int x, int y);

void ResizeButtons(Window *w, byte left, byte right);

void ResizeWindowForWidget(Window *w, int widget, int delta_x, int delta_y);

/**

 * Sets the enabled/disabled status of a widget.

 * By default, widgets are enabled.