--- a/src/ai/ai_squirrel.cpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/ai_squirrel.cpp	Sat Apr 14 20:38:10 2007 +0000
@@ -21,6 +21,7 @@
 
 /* Convert all AI related classes to Squirrel data */
 #define DEFINE_SQUIRREL_CLASS
+#include "api/ai_abstractlist.hpp"
 #include "api/ai_accounting.hpp"
 #include "api/ai_base.hpp"
 #include "api/ai_cargo.hpp"

--- a/src/ai/api/ai_abstractlist.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_abstractlist.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -198,10 +198,16 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow inner classes/structs to be used as Squirrel parameters */
+	template <> AIAbstractList::Valuator *GetParam(ForceType<AIAbstractList::Valuator *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAbstractList::Valuator *)instance; }
+	template <> AIAbstractList::Valuator &GetParam(ForceType<AIAbstractList::Valuator &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList::Valuator *)instance; }
+	template <> const AIAbstractList::Valuator *GetParam(ForceType<const AIAbstractList::Valuator *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAbstractList::Valuator *)instance; }
 	template <> const AIAbstractList::Valuator &GetParam(ForceType<const AIAbstractList::Valuator &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList::Valuator *)instance; }
 
 	/* Allow AIAbstractList to be used as Squirrel parameter */
-	template <> AIAbstractList *GetParam(ForceType<AIAbstractList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAbstractList *)instance; }
+	template <> AIAbstractList *GetParam(ForceType<AIAbstractList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAbstractList *)instance; }
+	template <> AIAbstractList &GetParam(ForceType<AIAbstractList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList *)instance; }
+	template <> const AIAbstractList *GetParam(ForceType<const AIAbstractList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAbstractList *)instance; }
+	template <> const AIAbstractList &GetParam(ForceType<const AIAbstractList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAbstractList *)instance; }
 }; // namespace SQConvert
 
 void SQAIAbstractListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_accounting.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_accounting.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -54,7 +54,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIAccounting to be used as Squirrel parameter */
-	template <> AIAccounting *GetParam(ForceType<AIAccounting *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIAccounting *)instance; }
+	template <> AIAccounting *GetParam(ForceType<AIAccounting *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAccounting *)instance; }
+	template <> AIAccounting &GetParam(ForceType<AIAccounting &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAccounting *)instance; }
+	template <> const AIAccounting *GetParam(ForceType<const AIAccounting *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAccounting *)instance; }
+	template <> const AIAccounting &GetParam(ForceType<const AIAccounting &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAccounting *)instance; }
 }; // namespace SQConvert
 
 void SQAIAccountingRegister(Squirrel *engine) {

--- a/src/ai/api/ai_base.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_base.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -49,7 +49,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIBase to be used as Squirrel parameter */
-	template <> AIBase *GetParam(ForceType<AIBase *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIBase *)instance; }
+	template <> AIBase *GetParam(ForceType<AIBase *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIBase *)instance; }
+	template <> AIBase &GetParam(ForceType<AIBase &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBase *)instance; }
+	template <> const AIBase *GetParam(ForceType<const AIBase *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIBase *)instance; }
+	template <> const AIBase &GetParam(ForceType<const AIBase &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIBase *)instance; }
 }; // namespace SQConvert
 
 void SQAIBaseRegister(Squirrel *engine) {

--- a/src/ai/api/ai_cargo.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_cargo.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -53,7 +53,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AICargo to be used as Squirrel parameter */
-	template <> AICargo *GetParam(ForceType<AICargo *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICargo *)instance; }
+	template <> AICargo *GetParam(ForceType<AICargo *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AICargo *)instance; }
+	template <> AICargo &GetParam(ForceType<AICargo &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargo *)instance; }
+	template <> const AICargo *GetParam(ForceType<const AICargo *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AICargo *)instance; }
+	template <> const AICargo &GetParam(ForceType<const AICargo &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICargo *)instance; }
 }; // namespace SQConvert
 
 void SQAICargoRegister(Squirrel *engine) {

--- a/src/ai/api/ai_company.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_company.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -97,7 +97,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AICompany to be used as Squirrel parameter */
-	template <> AICompany *GetParam(ForceType<AICompany *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AICompany *)instance; }
+	template <> AICompany *GetParam(ForceType<AICompany *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AICompany *)instance; }
+	template <> AICompany &GetParam(ForceType<AICompany &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICompany *)instance; }
+	template <> const AICompany *GetParam(ForceType<const AICompany *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AICompany *)instance; }
+	template <> const AICompany &GetParam(ForceType<const AICompany &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AICompany *)instance; }
 }; // namespace SQConvert
 
 void SQAICompanyRegister(Squirrel *engine) {

--- a/src/ai/api/ai_execmode.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_execmode.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -48,7 +48,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIExecMode to be used as Squirrel parameter */
-	template <> AIExecMode *GetParam(ForceType<AIExecMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIExecMode *)instance; }
+	template <> AIExecMode *GetParam(ForceType<AIExecMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIExecMode *)instance; }
+	template <> AIExecMode &GetParam(ForceType<AIExecMode &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIExecMode *)instance; }
+	template <> const AIExecMode *GetParam(ForceType<const AIExecMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIExecMode *)instance; }
+	template <> const AIExecMode &GetParam(ForceType<const AIExecMode &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIExecMode *)instance; }
 }; // namespace SQConvert
 
 void SQAIExecModeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_industry.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_industry.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -62,7 +62,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIIndustry to be used as Squirrel parameter */
-	template <> AIIndustry *GetParam(ForceType<AIIndustry *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIIndustry *)instance; }
+	template <> AIIndustry *GetParam(ForceType<AIIndustry *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustry *)instance; }
+	template <> AIIndustry &GetParam(ForceType<AIIndustry &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustry *)instance; }
+	template <> const AIIndustry *GetParam(ForceType<const AIIndustry *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustry *)instance; }
+	template <> const AIIndustry &GetParam(ForceType<const AIIndustry &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustry *)instance; }
 }; // namespace SQConvert
 
 void SQAIIndustryRegister(Squirrel *engine) {

--- a/src/ai/api/ai_list.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_list.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -34,7 +34,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIList to be used as Squirrel parameter */
-	template <> AIList *GetParam(ForceType<AIList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIList *)instance; }
+	template <> AIList *GetParam(ForceType<AIList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIList *)instance; }
+	template <> AIList &GetParam(ForceType<AIList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIList *)instance; }
+	template <> const AIList *GetParam(ForceType<const AIList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIList *)instance; }
+	template <> const AIList &GetParam(ForceType<const AIList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIList *)instance; }
 }; // namespace SQConvert
 
 void SQAIListRegister(Squirrel *engine) {
@@ -44,8 +47,8 @@
 
 	SQAIList.DefSQStaticMethod(engine, &AIList::GetClassName, "GetClassName", 1, "x");
 
-	SQAIList.DefSQMethod(engine, &AIList::AddItem,         "AddItem",         2, "xi");
-	SQAIList.DefSQMethod(engine, &AIList::RemoveItem,      "RemoveItem",      2, "xi");
+	SQAIList.DefSQMethod(engine, &AIList::AddItem,    "AddItem",    2, "xi");
+	SQAIList.DefSQMethod(engine, &AIList::RemoveItem, "RemoveItem", 2, "xi");
 
 	SQAIList.PostRegister(engine);
 }

--- a/src/ai/api/ai_map.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_map.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -128,7 +128,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIMap to be used as Squirrel parameter */
-	template <> AIMap *GetParam(ForceType<AIMap *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIMap *)instance; }
+	template <> AIMap *GetParam(ForceType<AIMap *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIMap *)instance; }
+	template <> AIMap &GetParam(ForceType<AIMap &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIMap *)instance; }
+	template <> const AIMap *GetParam(ForceType<const AIMap *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIMap *)instance; }
+	template <> const AIMap &GetParam(ForceType<const AIMap &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIMap *)instance; }
 }; // namespace SQConvert
 
 void SQAIMapRegister(Squirrel *engine) {

--- a/src/ai/api/ai_order.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_order.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -167,7 +167,10 @@
 	template <> int Return<AIOrder::AIOrderFlags>(HSQUIRRELVM vm, AIOrder::AIOrderFlags res) { sq_pushinteger(vm, (int32)res); return 1; }
 
 	/* Allow AIOrder to be used as Squirrel parameter */
-	template <> AIOrder *GetParam(ForceType<AIOrder *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIOrder *)instance; }
+	template <> AIOrder *GetParam(ForceType<AIOrder *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIOrder *)instance; }
+	template <> AIOrder &GetParam(ForceType<AIOrder &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIOrder *)instance; }
+	template <> const AIOrder *GetParam(ForceType<const AIOrder *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIOrder *)instance; }
+	template <> const AIOrder &GetParam(ForceType<const AIOrder &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIOrder *)instance; }
 }; // namespace SQConvert
 
 void SQAIOrderRegister(Squirrel *engine) {

--- a/src/ai/api/ai_road.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_road.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -177,7 +177,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIRoad to be used as Squirrel parameter */
-	template <> AIRoad *GetParam(ForceType<AIRoad *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIRoad *)instance; }
+	template <> AIRoad *GetParam(ForceType<AIRoad *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIRoad *)instance; }
+	template <> AIRoad &GetParam(ForceType<AIRoad &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRoad *)instance; }
+	template <> const AIRoad *GetParam(ForceType<const AIRoad *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIRoad *)instance; }
+	template <> const AIRoad &GetParam(ForceType<const AIRoad &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRoad *)instance; }
 }; // namespace SQConvert
 
 void SQAIRoadRegister(Squirrel *engine) {

--- a/src/ai/api/ai_settings.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_settings.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -33,7 +33,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AISettings to be used as Squirrel parameter */
-	template <> AISettings *GetParam(ForceType<AISettings *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISettings *)instance; }
+	template <> AISettings *GetParam(ForceType<AISettings *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AISettings *)instance; }
+	template <> AISettings &GetParam(ForceType<AISettings &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISettings *)instance; }
+	template <> const AISettings *GetParam(ForceType<const AISettings *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AISettings *)instance; }
+	template <> const AISettings &GetParam(ForceType<const AISettings &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISettings *)instance; }
 }; // namespace SQConvert
 
 void SQAISettingsRegister(Squirrel *engine) {

--- a/src/ai/api/ai_sign.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_sign.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -81,7 +81,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AISign to be used as Squirrel parameter */
-	template <> AISign *GetParam(ForceType<AISign *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AISign *)instance; }
+	template <> AISign *GetParam(ForceType<AISign *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AISign *)instance; }
+	template <> AISign &GetParam(ForceType<AISign &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISign *)instance; }
+	template <> const AISign *GetParam(ForceType<const AISign *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AISign *)instance; }
+	template <> const AISign &GetParam(ForceType<const AISign &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AISign *)instance; }
 }; // namespace SQConvert
 
 void SQAISignRegister(Squirrel *engine) {

--- a/src/ai/api/ai_testmode.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_testmode.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -50,7 +50,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITestMode to be used as Squirrel parameter */
-	template <> AITestMode *GetParam(ForceType<AITestMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITestMode *)instance; }
+	template <> AITestMode *GetParam(ForceType<AITestMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITestMode *)instance; }
+	template <> AITestMode &GetParam(ForceType<AITestMode &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITestMode *)instance; }
+	template <> const AITestMode *GetParam(ForceType<const AITestMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITestMode *)instance; }
+	template <> const AITestMode &GetParam(ForceType<const AITestMode &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITestMode *)instance; }
 }; // namespace SQConvert
 
 void SQAITestModeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_tilelist.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_tilelist.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -62,7 +62,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITileList to be used as Squirrel parameter */
-	template <> AITileList *GetParam(ForceType<AITileList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileList *)instance; }
+	template <> AITileList *GetParam(ForceType<AITileList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList *)instance; }
+	template <> AITileList &GetParam(ForceType<AITileList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList *)instance; }
+	template <> const AITileList *GetParam(ForceType<const AITileList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList *)instance; }
+	template <> const AITileList &GetParam(ForceType<const AITileList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList *)instance; }
 }; // namespace SQConvert
 
 void SQAITileListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_tilelist_valuator.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_tilelist_valuator.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -26,7 +26,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITileListBuildable to be used as Squirrel parameter */
-	template <> AITileListBuildable *GetParam(ForceType<AITileListBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListBuildable *)instance; }
+	template <> AITileListBuildable *GetParam(ForceType<AITileListBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListBuildable *)instance; }
+	template <> AITileListBuildable &GetParam(ForceType<AITileListBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildable *)instance; }
+	template <> const AITileListBuildable *GetParam(ForceType<const AITileListBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListBuildable *)instance; }
+	template <> const AITileListBuildable &GetParam(ForceType<const AITileListBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildable *)instance; }
 }; // namespace SQConvert
 
 void SQAITileListBuildableRegister(Squirrel *engine) {

--- a/src/ai/api/ai_town.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_town.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -70,7 +70,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITown to be used as Squirrel parameter */
-	template <> AITown *GetParam(ForceType<AITown *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITown *)instance; }
+	template <> AITown *GetParam(ForceType<AITown *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITown *)instance; }
+	template <> AITown &GetParam(ForceType<AITown &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITown *)instance; }
+	template <> const AITown *GetParam(ForceType<const AITown *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITown *)instance; }
+	template <> const AITown &GetParam(ForceType<const AITown &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITown *)instance; }
 }; // namespace SQConvert
 
 void SQAITownRegister(Squirrel *engine) {

--- a/src/ai/api/ai_townlist.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_townlist.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -26,7 +26,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITownList to be used as Squirrel parameter */
-	template <> AITownList *GetParam(ForceType<AITownList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITownList *)instance; }
+	template <> AITownList *GetParam(ForceType<AITownList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownList *)instance; }
+	template <> AITownList &GetParam(ForceType<AITownList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownList *)instance; }
+	template <> const AITownList *GetParam(ForceType<const AITownList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownList *)instance; }
+	template <> const AITownList &GetParam(ForceType<const AITownList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownList *)instance; }
 }; // namespace SQConvert
 
 void SQAITownListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_townlist_valuator.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_townlist_valuator.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -26,7 +26,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITownListGetPopulation to be used as Squirrel parameter */
-	template <> AITownListGetPopulation *GetParam(ForceType<AITownListGetPopulation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITownListGetPopulation *)instance; }
+	template <> AITownListGetPopulation *GetParam(ForceType<AITownListGetPopulation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListGetPopulation *)instance; }
+	template <> AITownListGetPopulation &GetParam(ForceType<AITownListGetPopulation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListGetPopulation *)instance; }
+	template <> const AITownListGetPopulation *GetParam(ForceType<const AITownListGetPopulation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListGetPopulation *)instance; }
+	template <> const AITownListGetPopulation &GetParam(ForceType<const AITownListGetPopulation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListGetPopulation *)instance; }
 }; // namespace SQConvert
 
 void SQAITownListGetPopulationRegister(Squirrel *engine) {
@@ -59,7 +62,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITownListGetLocation to be used as Squirrel parameter */
-	template <> AITownListGetLocation *GetParam(ForceType<AITownListGetLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITownListGetLocation *)instance; }
+	template <> AITownListGetLocation *GetParam(ForceType<AITownListGetLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListGetLocation *)instance; }
+	template <> AITownListGetLocation &GetParam(ForceType<AITownListGetLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListGetLocation *)instance; }
+	template <> const AITownListGetLocation *GetParam(ForceType<const AITownListGetLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListGetLocation *)instance; }
+	template <> const AITownListGetLocation &GetParam(ForceType<const AITownListGetLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListGetLocation *)instance; }
 }; // namespace SQConvert
 
 void SQAITownListGetLocationRegister(Squirrel *engine) {

--- a/src/ai/api/ai_transactionmode.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_transactionmode.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -109,7 +109,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AITransactionMode to be used as Squirrel parameter */
-	template <> AITransactionMode *GetParam(ForceType<AITransactionMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITransactionMode *)instance; }
+	template <> AITransactionMode *GetParam(ForceType<AITransactionMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITransactionMode *)instance; }
+	template <> AITransactionMode &GetParam(ForceType<AITransactionMode &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITransactionMode *)instance; }
+	template <> const AITransactionMode *GetParam(ForceType<const AITransactionMode *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITransactionMode *)instance; }
+	template <> const AITransactionMode &GetParam(ForceType<const AITransactionMode &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITransactionMode *)instance; }
 }; // namespace SQConvert
 
 void SQAITransactionModeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_vehicle.hpp	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/ai_vehicle.hpp	Sat Apr 14 20:38:10 2007 +0000
@@ -126,7 +126,10 @@
 #ifdef DEFINE_SQUIRREL_CLASS
 namespace SQConvert {
 	/* Allow AIVehicle to be used as Squirrel parameter */
-	template <> AIVehicle *GetParam(ForceType<AIVehicle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AIVehicle *)instance; }
+	template <> AIVehicle *GetParam(ForceType<AIVehicle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicle *)instance; }
+	template <> AIVehicle &GetParam(ForceType<AIVehicle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicle *)instance; }
+	template <> const AIVehicle *GetParam(ForceType<const AIVehicle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicle *)instance; }
+	template <> const AIVehicle &GetParam(ForceType<const AIVehicle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicle *)instance; }
 }; // namespace SQConvert
 
 void SQAIVehicleRegister(Squirrel *engine) {

--- a/src/ai/api/squirrel_export.awk	Sat Apr 14 20:17:36 2007 +0000
+++ b/src/ai/api/squirrel_export.awk	Sat Apr 14 20:38:10 2007 +0000
@@ -16,6 +16,13 @@
 	return
 }
 
+function dump_class_templates(name) {
+	print "	template <> "       name " *GetParam(ForceType<"       name " *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (" name " *)instance; }"
+	print "	template <> "       name " &GetParam(ForceType<"       name " &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(" name " *)instance; }"
+	print "	template <> const " name " *GetParam(ForceType<const " name " *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (" name " *)instance; }"
+	print "	template <> const " name " &GetParam(ForceType<const " name " &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(" name " *)instance; }"
+}
+
 BEGIN {
 	enum_size = 0
 	enum_value_size = 0
@@ -23,6 +30,7 @@
 	method_size = 0
 	static_method_size = 0
 	virtual_class = "false"
+	super_cls = ""
 	cls = ""
 	start_squirrel_define_on_next_line = "false"
 	cls_level = 0
@@ -42,6 +50,11 @@
 	if (cls_level == 0) {
 		public = "false"
 		cls = $2
+		if (match($4, "public") || match($4, "protected") || match($4, "private")) {
+			super_cls = $5
+		} else {
+			super_cls = $4
+		}
 	} else if (cls_level == 1) {
 		struct_size++
 		structs[struct_size] = cls "::" $2
@@ -124,7 +137,7 @@
 		}
 		print "	/* Allow inner classes/structs to be used as Squirrel parameters */"
 		for (i = 1; i <= struct_size; i++) {
-			print "	template <> " structs[i] " *GetParam(ForceType<" structs[i] " *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (" structs[i] " *)instance; }"
+			dump_class_templates(structs[i])
 			delete structs[i]
 		}
 	}
@@ -136,8 +149,7 @@
 		print ""
 	}
 	print "	/* Allow " cls " to be used as Squirrel parameter */"
-	print "	template <> " cls " *GetParam(ForceType<" cls " *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (" cls " *)instance; }"
-	# TODO returning...
+	dump_class_templates(cls)
 
 	print "}; // namespace SQConvert"
 
@@ -146,7 +158,11 @@
 		# Then do the registration functions of the class. */
 		print "void SQ" cls "Register(Squirrel *engine) {"
 		print "	DefSQClass <" cls "> SQ" cls "(\"" cls "\");"
-		print "	SQ" cls ".PreRegister(engine);"
+		if (super_cls == "AIObject" || super_cls == "AIAbstractList::Valuator") {
+			print "	SQ" cls ".PreRegister(engine);"
+		} else {
+			print "	SQ" cls ".PreRegister(engine, \"" super_cls "\");"
+		}
 		print "	SQ" cls ".AddConstructor(engine);"
 		print ""
 
@@ -237,7 +253,7 @@
 	len = 1;
 	for (len = 1; params[len] != ""; len++) {
 		sub("^[ 	]*", "", params[len])
-		if (match(params[len], "\\*")) {
+		if (match(params[len], "\\*") || match(params[len], "&")) {
 			if (match(params[len], "^char")) {
 				types = types "s"
 			} else {