print("");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		list.SetValue(i, 2);

		print("   " + i);

	}

	print("");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		print("   " + i);

	}

	list = AIList();

	print("");

	print(" Value Ascending");

	list.AddItem( 5, 10);

	list.AddItem(10, 10);

	list.AddItem(15, 20);

	list.AddItem(20, 20);

	list.AddItem(25, 30);

	list.AddItem(30, 30);

	list.AddItem(35, 40);

	list.AddItem(40, 40);

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

	print("");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		list.SetValue(i, 50);

		print("   " + i);

	}

	print("");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		print("   " + i);

	}

	list = AIList();

	print("");

	print(" Item Descending");

	list.AddItem( 5, 10);

	list.AddItem(10, 10);

	list.AddItem(15, 20);

	list.AddItem(20, 20);

	list.AddItem(25, 30);

	list.AddItem(30, 30);

	list.AddItem(35, 40);

	list.AddItem(40, 40);

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

	print("");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		list.SetValue(i, 2);

		print("   " + i);

	}

	print("");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		print("   " + i);

	}

	list = AIList();

	print("");

	print(" Item Ascending");

	list.AddItem( 5, 10);

	list.AddItem(10, 10);

	list.AddItem(15, 20);

	list.AddItem(20, 20);

	list.AddItem(25, 30);

	list.AddItem(30, 30);

	list.AddItem(35, 40);

	list.AddItem(40, 40);

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

	print("  EnableWagonRemoval():     " + AIGroup.EnableWagonRemoval(false));

	print("  HasWagonRemoval():        " + AIGroup.HasWagonRemoval());

}

function Regression::Industry()

{

	local j = 0;

	print("");

	print("--Industry--");

	print("  GetIndustryCount():  " + AIIndustry.GetIndustryCount());

	local list = AIIndustryList();

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		if (AIIndustry.IsValidIndustry(i)) j++;

		print("  Industry " + i);

		print("    IsValidIndustry(): " + AIIndustry.IsValidIndustry(i));

		print("    GetName():         " + AIIndustry.GetName(i));

		print("    GetLocation():     " + AIIndustry.GetLocation(i));

		print("    IsCargoAccepted(): " + AIIndustry.IsCargoAccepted(i, 1));

		local cargo_list = AICargoList();

		for (local j = cargo_list.Begin(); cargo_list.HasNext(); j = cargo_list.Next()) {

			if (AIIndustry.IsCargoAccepted(i, j) || AIIndustry.GetLastMonthProduction(i,j) >= 0) {

				print("	   GetLastMonthProduction():  " + AIIndustry.GetLastMonthProduction(i, j));

	list.AddItem(1, 1);

	list.AddItem(2, 2);

	for (local i = 1000; i < 1100; i++) {

		list.AddItem(i, i);

	}

	list.RemoveItem(1050);

	list.RemoveItem(1150);

	list.ChangeItem(1051, 12);

	print("  Count():       " + list.Count());

	print("  HasItem(1050): " + list.HasItem(1050));

	print("  HasItem(1051): " + list.HasItem(1051));

	print("  IsEmpty():     " + list.IsEmpty());

	print("  List Dump:");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		print("    " + i + " => " + list.GetValue(i));

	}

	list.Valuate(CustomValuator);

	print("  Custom ListDump:");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		print("    " + i + " => " + list.GetValue(i));

	}

	list.Valuate(function (a) { return a * 42; });

	print("  Custom ListDump:");

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

	local j = 0;

	print("");

	print("--Sign--");

	print("  BuildSign(33410, 'Some Sign'):       " + AISign.BuildSign(33410, "Some Sign"));

	print("  BuildSign(33411, 'Test'):            " + AISign.BuildSign(33411, "Test"));

	print("  SetName(1, 'Test2'):                 " + AISign.SetName(1, "Test2"));

	local sign_id = AISign.BuildSign(33409, "Some other Sign");

	print("  BuildSign(33409, 'Some other Sign'): " + sign_id);

	print("  RemoveSign(" + sign_id + "):                       " + AISign.RemoveSign(sign_id));

	print("");

	local list = AISignList();

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		j++;

		print("  Sign " + i);

		print("    IsValidSign():   " + AISign.IsValidSign(i));

		print("    GetName():       " + AISign.GetName(i));

		print("    GetLocation():   " + AISign.GetLocation(i));

	}

	print("  Valid Signs:       " + j);

}

function Regression::Station()

{

		print("    " + i + " => " + list.GetValue(i));

	}

}

function Regression::Town()

{

	local j = 0;

	print("");

	print("--Town--");

	print("  GetTownCount():    " + AITown.GetTownCount());

	local list = AITownList();

	for (local i = list.Begin(); list.HasNext(); i = list.Next()) {

		if (AITown.IsValidTown(i)) j++;

		print("  Town " + i);

		print("    IsValidTown():   " + AITown.IsValidTown(i));

		print("    GetName():       " + AITown.GetName(i));

		print("    GetPopulation(): " + AITown.GetPopulation(i));

		print("    GetLocation():   " + AITown.GetLocation(i));

		print("    GetHouseCount(): " + AITown.GetHouseCount(i));

		print("    GetRating():     " + AITown.GetRating(i, AICompany.COMPANY_SELF));

	}

	print("  Valid Towns:       " + j);

	print("  GetTownCount():    " + AITown.GetTownCount());

 * Class that creates a list which can keep item/value pairs, which you can walk.

 */

class AIAbstractList : public AIObject {

public:

	static const char *GetClassName() { return "AIAbstractList"; }

	/** Type of sorter */

	enum SorterType {

		SORT_BY_VALUE, //!< Sort the list based on the value of the item.

		SORT_BY_ITEM,  //!< Sort the list based on the item itself.

	};

private:

	AIAbstractListSorter *sorter;

	SorterType sorter_type;

	bool sort_ascending;

	bool initialized;

public:

	typedef std::set<int32> AIItemList;                       //!< The list of items inside the bucket

	typedef std::map<int32, AIItemList> AIAbstractListBucket; //!< The bucket list per value

	typedef std::map<int32, int32> AIAbstractListMap;         //!< List per item

	AIAbstractListMap items;           //!< The items in the list

	 * @param value the value to give to the item

	 * @return true if we could set the item to value, false otherwise.

	 * @note Changing values of items while looping through a list might cause

	 *  entries to be skipped. Be very careful with such operations.

	 */

	bool SetValue(int32 item, int32 value);

	/**

	 * Sort this list by the given sorter and direction.

	 * @param sorter    the type of sorter to use

	 * @param ascending if true, lowest value is on top, else at bottom.

	 * @note the current item stays at the same place.

	 */

	void Sort(SorterType sorter, bool ascending);

	/**

	 * Add one list to an other one.

	 * @param list The list that will be added to the caller.

	 * @post The list to be added ('list') stays unmodified.

	 * @note All added items keep their value as it was in 'list'.

	 * @note If the item already exists inside the caller, the value of the

	 *  list that is added is set on the item.

	 */

	void AddList(AIAbstractList *list);

	template <> const AIAbstractList &GetParam(ForceType<const AIAbstractList &>, HSQUIRRELVM vm, int index, SQAutoFreePointers *ptr) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList *)instance; }

	template <> int Return<AIAbstractList *>(HSQUIRRELVM vm, AIAbstractList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAbstractList", res, NULL, DefSQDestructorCallback<AIAbstractList>); return 1; }

}; // namespace SQConvert

void SQAIAbstractList_Register(Squirrel *engine) {

	DefSQClass <AIAbstractList> SQAIAbstractList("AIAbstractList");

	SQAIAbstractList.PreRegister(engine);

	SQAIAbstractList.AddConstructor<void (AIAbstractList::*)(), 1>(engine, "x");

	SQAIAbstractList.DefSQConst(engine, AIAbstractList::SORT_BY_VALUE, "SORT_BY_VALUE");

	SQAIAbstractList.DefSQConst(engine, AIAbstractList::SORT_BY_ITEM,  "SORT_BY_ITEM");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Clear,              "Clear",              1, "x");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasItem,            "HasItem",            2, "xi");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Begin,              "Begin",              1, "x");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Next,               "Next",               1, "x");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::IsEmpty,            "IsEmpty",            1, "x");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasNext,            "HasNext",            1, "x");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Count,              "Count",              1, "x");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::GetValue,           "GetValue",           2, "xi");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::SetValue,           "SetValue",           3, "xii");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Sort,               "Sort",               3, "xib");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::AddList,            "AddList",            2, "xx");

	SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveAboveValue,   "RemoveAboveValue",   2, "xi");

	if (name == "AIEvent") {

		print "	template <> int Return<" name " *>(HSQUIRRELVM vm, " name " *res) { if (res == NULL) { sq_pushnull(vm); return 1; } Squirrel::CreateClassInstanceVM(vm, \"" name "\", res, NULL, DefSQDestructorCallback<" name ">); return 1; }"

	} else {

		print "	template <> int Return<" name " *>(HSQUIRRELVM vm, " name " *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, \"" name "\", res, NULL, DefSQDestructorCallback<" name ">); return 1; }"

	}

}

BEGIN {

	enum_size = 0

	enum_value_size = 0

	enum_string_to_error_size = 0

	enum_error_to_string_size = 0

	struct_size = 0

	method_size = 0

	static_method_size = 0

	virtual_class = "false"

	super_cls = ""

	cls = ""

	start_squirrel_define_on_next_line = "false"

	cls_level = 0

	RS = "\r|\n"

}

/@file/ {

	# Enum values

	mlen = 0

	for (i = 1; i <= enum_value_size; i++) {

		if (mlen <= length(enum_value[i])) mlen = length(enum_value[i])

	}

	for (i = 1; i <= enum_value_size; i++) {

		print "	SQ" cls ".DefSQConst(engine, " cls "::" enum_value[i] ", " substr(spaces, 1, mlen - length(enum_value[i])) "\""  enum_value[i] "\");"

		delete enum_value[i]

	}

	if (enum_value_size != 0) print ""

	# Mapping of OTTD strings to errors

	mlen = 0

	for (i = 1; i <= enum_string_to_error_size; i++) {

		if (mlen <= length(enum_string_to_error_mapping_string[i])) mlen = length(enum_string_to_error_mapping_string[i])

	}

	for (i = 1; i <= enum_string_to_error_size; i++) {

		print "	AIError::RegisterErrorMap(" enum_string_to_error_mapping_string[i] ", " substr(spaces, 1, mlen - length(enum_string_to_error_mapping_string[i]))  cls "::" enum_string_to_error_mapping_error[i] ");"

		delete enum_string_to_error_mapping_string[i]

	}

	if (enum_string_to_error_size != 0) print ""

					enum_string_to_error_mapping_string[enum_string_to_error_size] = mapitems[i]

					enum_string_to_error_mapping_error[enum_string_to_error_size] = $1

				}

				enum_error_to_string_size++

				enum_error_to_string_mapping[enum_error_to_string_size] = $1

			}

		}

		next

	}

}

# Add a method to the list

/^.*\(.*\).*$/ {

	if (cls_level != 1) next

	if (match($0, "~")) next

	is_static = match($0, "static")

	if (match($0, "virtual")) {

		virtual_class = "true"

	}

	gsub("virtual", "", $0)

	gsub("static", "", $0)

	gsub("const", "", $0)

	if (nparam != 0) sq_setparamscheck(this->vm, nparam, OTTD2FS(params));

	sq_setnativeclosurename(this->vm, -1, OTTD2FS(method_name));

	sq_newslot(this->vm, -3, SQFalse);

}

void Squirrel::AddConst(const char *var_name, int value)

{

	sq_pushstring(this->vm, OTTD2FS(var_name), -1);

	sq_pushinteger(this->vm, value);

	sq_newslot(this->vm, -3, SQTrue);

}

void Squirrel::AddClassBegin(const char *class_name)

{

	sq_pushroottable(this->vm);

	sq_pushstring(this->vm, OTTD2FS(class_name), -1);

	sq_newclass(this->vm, SQFalse);

}

void Squirrel::AddClassBegin(const char *class_name, const char *parent_class)

{

	sq_pushroottable(this->vm);

	sq_pushstring(this->vm, OTTD2FS(class_name), -1);

	sq_pushstring(this->vm, OTTD2FS(parent_class), -1);

	 * Adds a function to the stack. Depending on the current state this means

	 *  either a method or a global function.

	 */

	void AddMethod(const char *method_name, SQFUNCTION proc, uint nparam = 0, const char *params = NULL, void *userdata = NULL, int size = 0);

	/**

	 * Adds a const to the stack. Depending on the current state this means

	 *  either a const to a class or to the global space.

	 */

	void AddConst(const char *var_name, int value);

	/**

	 * Adds a class to the global scope. Make sure to call AddClassEnd when you

	 *  are done adding methods.

	 */

	void AddClassBegin(const char *class_name);

	/**

	 * Adds a class to the global scope, extending 'parent_class'.

	 * Make sure to call AddClassEnd when you are done adding methods.

	 */

	void AddClassBegin(const char *class_name, const char *parent_class);

	/**