--- a/src/ai/api/ai_abstractlist.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_abstractlist.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -9,14 +9,14 @@
 	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; }
-	template <> int Return<AIAbstractList::Valuator *>(HSQUIRRELVM vm, AIAbstractList::Valuator *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAbstractList::Valuator", res, NULL, DefSQDestructorCallback<AIAbstractList::Valuator>); return 1; }
+	template <> int Return<AIAbstractList::Valuator *>(HSQUIRRELVM vm, AIAbstractList::Valuator *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAbstractList::Valuator", res, NULL, DefSQDestructorCallback<AIAbstractList::Valuator>); return 1; }
 
 	/* 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 <> 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; }
-	template <> int Return<AIAbstractList *>(HSQUIRRELVM vm, AIAbstractList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAbstractList", res, NULL, DefSQDestructorCallback<AIAbstractList>); return 1; }
+	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 SQAIAbstractListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_accounting.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_accounting.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIAccounting *>(HSQUIRRELVM vm, AIAccounting *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAccounting", res, NULL, DefSQDestructorCallback<AIAccounting>); return 1; }
+	template <> int Return<AIAccounting *>(HSQUIRRELVM vm, AIAccounting *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAccounting", res, NULL, DefSQDestructorCallback<AIAccounting>); return 1; }
 }; // namespace SQConvert
 
 void SQAIAccountingRegister(Squirrel *engine) {

--- a/src/ai/api/ai_airport.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_airport.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -10,7 +10,7 @@
 	template <> AIAirport &GetParam(ForceType<AIAirport &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAirport *)instance; }
 	template <> const AIAirport *GetParam(ForceType<const AIAirport *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIAirport *)instance; }
 	template <> const AIAirport &GetParam(ForceType<const AIAirport &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIAirport *)instance; }
-	template <> int Return<AIAirport *>(HSQUIRRELVM vm, AIAirport *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAirport", res, NULL, DefSQDestructorCallback<AIAirport>); return 1; }
+	template <> int Return<AIAirport *>(HSQUIRRELVM vm, AIAirport *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIAirport", res, NULL, DefSQDestructorCallback<AIAirport>); return 1; }
 }; // namespace SQConvert
 
 void SQAIAirportRegister(Squirrel *engine) {

--- a/src/ai/api/ai_base.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_base.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIBase *>(HSQUIRRELVM vm, AIBase *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIBase", res, NULL, DefSQDestructorCallback<AIBase>); return 1; }
+	template <> int Return<AIBase *>(HSQUIRRELVM vm, AIBase *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIBase", res, NULL, DefSQDestructorCallback<AIBase>); return 1; }
 }; // namespace SQConvert
 
 void SQAIBaseRegister(Squirrel *engine) {

--- a/src/ai/api/ai_cargo.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_cargo.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AICargo *>(HSQUIRRELVM vm, AICargo *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICargo", res, NULL, DefSQDestructorCallback<AICargo>); return 1; }
+	template <> int Return<AICargo *>(HSQUIRRELVM vm, AICargo *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICargo", res, NULL, DefSQDestructorCallback<AICargo>); return 1; }
 }; // namespace SQConvert
 
 void SQAICargoRegister(Squirrel *engine) {

--- a/src/ai/api/ai_company.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_company.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -10,7 +10,7 @@
 	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; }
-	template <> int Return<AICompany *>(HSQUIRRELVM vm, AICompany *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICompany", res, NULL, DefSQDestructorCallback<AICompany>); return 1; }
+	template <> int Return<AICompany *>(HSQUIRRELVM vm, AICompany *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AICompany", res, NULL, DefSQDestructorCallback<AICompany>); return 1; }
 }; // namespace SQConvert
 
 void SQAICompanyRegister(Squirrel *engine) {

--- a/src/ai/api/ai_execmode.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_execmode.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIExecMode *>(HSQUIRRELVM vm, AIExecMode *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIExecMode", res, NULL, DefSQDestructorCallback<AIExecMode>); return 1; }
+	template <> int Return<AIExecMode *>(HSQUIRRELVM vm, AIExecMode *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIExecMode", res, NULL, DefSQDestructorCallback<AIExecMode>); return 1; }
 }; // namespace SQConvert
 
 void SQAIExecModeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_industry.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_industry.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIIndustry *>(HSQUIRRELVM vm, AIIndustry *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustry", res, NULL, DefSQDestructorCallback<AIIndustry>); return 1; }
+	template <> int Return<AIIndustry *>(HSQUIRRELVM vm, AIIndustry *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustry", res, NULL, DefSQDestructorCallback<AIIndustry>); return 1; }
 }; // namespace SQConvert
 
 void SQAIIndustryRegister(Squirrel *engine) {

--- a/src/ai/api/ai_industrylist.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_industrylist.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIIndustryList &GetParam(ForceType<AIIndustryList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList *)instance; }
 	template <> const AIIndustryList *GetParam(ForceType<const AIIndustryList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustryList *)instance; }
 	template <> const AIIndustryList &GetParam(ForceType<const AIIndustryList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryList *)instance; }
-	template <> int Return<AIIndustryList *>(HSQUIRRELVM vm, AIIndustryList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryList", res, NULL, DefSQDestructorCallback<AIIndustryList>); return 1; }
+	template <> int Return<AIIndustryList *>(HSQUIRRELVM vm, AIIndustryList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryList", res, NULL, DefSQDestructorCallback<AIIndustryList>); return 1; }
 }; // namespace SQConvert
 
 void SQAIIndustryListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_industrylist_valuator.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_industrylist_valuator.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIIndustryListProduction &GetParam(ForceType<AIIndustryListProduction &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListProduction *)instance; }
 	template <> const AIIndustryListProduction *GetParam(ForceType<const AIIndustryListProduction *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustryListProduction *)instance; }
 	template <> const AIIndustryListProduction &GetParam(ForceType<const AIIndustryListProduction &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListProduction *)instance; }
-	template <> int Return<AIIndustryListProduction *>(HSQUIRRELVM vm, AIIndustryListProduction *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListProduction", res, NULL, DefSQDestructorCallback<AIIndustryListProduction>); return 1; }
+	template <> int Return<AIIndustryListProduction *>(HSQUIRRELVM vm, AIIndustryListProduction *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListProduction", res, NULL, DefSQDestructorCallback<AIIndustryListProduction>); return 1; }
 }; // namespace SQConvert
 
 void SQAIIndustryListProductionRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AIIndustryListLocation &GetParam(ForceType<AIIndustryListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListLocation *)instance; }
 	template <> const AIIndustryListLocation *GetParam(ForceType<const AIIndustryListLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustryListLocation *)instance; }
 	template <> const AIIndustryListLocation &GetParam(ForceType<const AIIndustryListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListLocation *)instance; }
-	template <> int Return<AIIndustryListLocation *>(HSQUIRRELVM vm, AIIndustryListLocation *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListLocation", res, NULL, DefSQDestructorCallback<AIIndustryListLocation>); return 1; }
+	template <> int Return<AIIndustryListLocation *>(HSQUIRRELVM vm, AIIndustryListLocation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListLocation", res, NULL, DefSQDestructorCallback<AIIndustryListLocation>); return 1; }
 }; // namespace SQConvert
 
 void SQAIIndustryListLocationRegister(Squirrel *engine) {
@@ -44,7 +44,7 @@
 	template <> AIIndustryListDistanceManhattanToTile &GetParam(ForceType<AIIndustryListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListDistanceManhattanToTile *)instance; }
 	template <> const AIIndustryListDistanceManhattanToTile *GetParam(ForceType<const AIIndustryListDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustryListDistanceManhattanToTile *)instance; }
 	template <> const AIIndustryListDistanceManhattanToTile &GetParam(ForceType<const AIIndustryListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListDistanceManhattanToTile *)instance; }
-	template <> int Return<AIIndustryListDistanceManhattanToTile *>(HSQUIRRELVM vm, AIIndustryListDistanceManhattanToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AIIndustryListDistanceManhattanToTile>); return 1; }
+	template <> int Return<AIIndustryListDistanceManhattanToTile *>(HSQUIRRELVM vm, AIIndustryListDistanceManhattanToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AIIndustryListDistanceManhattanToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAIIndustryListDistanceManhattanToTileRegister(Squirrel *engine) {
@@ -63,7 +63,7 @@
 	template <> AIIndustryListDistanceSquareToTile &GetParam(ForceType<AIIndustryListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListDistanceSquareToTile *)instance; }
 	template <> const AIIndustryListDistanceSquareToTile *GetParam(ForceType<const AIIndustryListDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIIndustryListDistanceSquareToTile *)instance; }
 	template <> const AIIndustryListDistanceSquareToTile &GetParam(ForceType<const AIIndustryListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIIndustryListDistanceSquareToTile *)instance; }
-	template <> int Return<AIIndustryListDistanceSquareToTile *>(HSQUIRRELVM vm, AIIndustryListDistanceSquareToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AIIndustryListDistanceSquareToTile>); return 1; }
+	template <> int Return<AIIndustryListDistanceSquareToTile *>(HSQUIRRELVM vm, AIIndustryListDistanceSquareToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIIndustryListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AIIndustryListDistanceSquareToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAIIndustryListDistanceSquareToTileRegister(Squirrel *engine) {

--- a/src/ai/api/ai_list.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_list.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIList *>(HSQUIRRELVM vm, AIList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIList", res, NULL, DefSQDestructorCallback<AIList>); return 1; }
+	template <> int Return<AIList *>(HSQUIRRELVM vm, AIList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIList", res, NULL, DefSQDestructorCallback<AIList>); return 1; }
 }; // namespace SQConvert
 
 void SQAIListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_list_valuator.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_list_valuator.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIListRandomize &GetParam(ForceType<AIListRandomize &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIListRandomize *)instance; }
 	template <> const AIListRandomize *GetParam(ForceType<const AIListRandomize *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIListRandomize *)instance; }
 	template <> const AIListRandomize &GetParam(ForceType<const AIListRandomize &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIListRandomize *)instance; }
-	template <> int Return<AIListRandomize *>(HSQUIRRELVM vm, AIListRandomize *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIListRandomize", res, NULL, DefSQDestructorCallback<AIListRandomize>); return 1; }
+	template <> int Return<AIListRandomize *>(HSQUIRRELVM vm, AIListRandomize *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIListRandomize", res, NULL, DefSQDestructorCallback<AIListRandomize>); return 1; }
 }; // namespace SQConvert
 
 void SQAIListRandomizeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_map.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_map.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIMap *>(HSQUIRRELVM vm, AIMap *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIMap", res, NULL, DefSQDestructorCallback<AIMap>); return 1; }
+	template <> int Return<AIMap *>(HSQUIRRELVM vm, AIMap *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIMap", res, NULL, DefSQDestructorCallback<AIMap>); return 1; }
 }; // namespace SQConvert
 
 void SQAIMapRegister(Squirrel *engine) {

--- a/src/ai/api/ai_object.cpp	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_object.cpp	Thu Jul 19 19:42:54 2007 +0000
@@ -72,6 +72,11 @@
 	return AIObject::GetDoCommandStruct(_current_player)->new_sign_id;
 }
 
+void **AIObject::GetEventPointer()
+{
+	return &AIObject::GetDoCommandStruct(_current_player)->event_data;
+}
+
 AIObject::AIDoCommandStruct *AIObject::GetDoCommandStruct(PlayerID player)
 {
 	/* Storage for data on per-AI level */

--- a/src/ai/api/ai_object.hpp	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_object.hpp	Thu Jul 19 19:42:54 2007 +0000
@@ -29,6 +29,7 @@
 		CommandCost costs;
 		VehicleID new_vehicle_id;
 		SignID new_sign_id;
+		void *event_data;
 	};
 
 	/**
@@ -92,6 +93,11 @@
 	 */
 	static SignID GetNewSignID();
 
+	/**
+	 * Get the pointer to store event data in.
+	 */
+	static void **GetEventPointer();
+
 public:
 	/**
 	 * Store a new_vehicle_id per player.

--- a/src/ai/api/ai_order.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_order.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -10,7 +10,7 @@
 	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; }
-	template <> int Return<AIOrder *>(HSQUIRRELVM vm, AIOrder *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIOrder", res, NULL, DefSQDestructorCallback<AIOrder>); return 1; }
+	template <> int Return<AIOrder *>(HSQUIRRELVM vm, AIOrder *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIOrder", res, NULL, DefSQDestructorCallback<AIOrder>); return 1; }
 }; // namespace SQConvert
 
 void SQAIOrderRegister(Squirrel *engine) {

--- a/src/ai/api/ai_pathfinder.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_pathfinder.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -10,7 +10,7 @@
 	template <> AIPathFinder &GetParam(ForceType<AIPathFinder &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIPathFinder *)instance; }
 	template <> const AIPathFinder *GetParam(ForceType<const AIPathFinder *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIPathFinder *)instance; }
 	template <> const AIPathFinder &GetParam(ForceType<const AIPathFinder &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIPathFinder *)instance; }
-	template <> int Return<AIPathFinder *>(HSQUIRRELVM vm, AIPathFinder *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIPathFinder", res, NULL, DefSQDestructorCallback<AIPathFinder>); return 1; }
+	template <> int Return<AIPathFinder *>(HSQUIRRELVM vm, AIPathFinder *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIPathFinder", res, NULL, DefSQDestructorCallback<AIPathFinder>); return 1; }
 }; // namespace SQConvert
 
 void SQAIPathFinderRegister(Squirrel *engine) {

--- a/src/ai/api/ai_pathfinder_stupid.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_pathfinder_stupid.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIPathFinderStupid &GetParam(ForceType<AIPathFinderStupid &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIPathFinderStupid *)instance; }
 	template <> const AIPathFinderStupid *GetParam(ForceType<const AIPathFinderStupid *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIPathFinderStupid *)instance; }
 	template <> const AIPathFinderStupid &GetParam(ForceType<const AIPathFinderStupid &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIPathFinderStupid *)instance; }
-	template <> int Return<AIPathFinderStupid *>(HSQUIRRELVM vm, AIPathFinderStupid *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIPathFinderStupid", res, NULL, DefSQDestructorCallback<AIPathFinderStupid>); return 1; }
+	template <> int Return<AIPathFinderStupid *>(HSQUIRRELVM vm, AIPathFinderStupid *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIPathFinderStupid", res, NULL, DefSQDestructorCallback<AIPathFinderStupid>); return 1; }
 }; // namespace SQConvert
 
 void SQAIPathFinderStupidRegister(Squirrel *engine) {

--- a/src/ai/api/ai_road.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_road.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIRoad *>(HSQUIRRELVM vm, AIRoad *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIRoad", res, NULL, DefSQDestructorCallback<AIRoad>); return 1; }
+	template <> int Return<AIRoad *>(HSQUIRRELVM vm, AIRoad *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIRoad", res, NULL, DefSQDestructorCallback<AIRoad>); return 1; }
 }; // namespace SQConvert
 
 void SQAIRoadRegister(Squirrel *engine) {

--- a/src/ai/api/ai_settings.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_settings.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AISettings *>(HSQUIRRELVM vm, AISettings *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISettings", res, NULL, DefSQDestructorCallback<AISettings>); return 1; }
+	template <> int Return<AISettings *>(HSQUIRRELVM vm, AISettings *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISettings", res, NULL, DefSQDestructorCallback<AISettings>); return 1; }
 }; // namespace SQConvert
 
 void SQAISettingsRegister(Squirrel *engine) {

--- a/src/ai/api/ai_sign.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_sign.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AISign *>(HSQUIRRELVM vm, AISign *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISign", res, NULL, DefSQDestructorCallback<AISign>); return 1; }
+	template <> int Return<AISign *>(HSQUIRRELVM vm, AISign *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AISign", res, NULL, DefSQDestructorCallback<AISign>); return 1; }
 }; // namespace SQConvert
 
 void SQAISignRegister(Squirrel *engine) {

--- a/src/ai/api/ai_station.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_station.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -10,7 +10,7 @@
 	template <> AIStation &GetParam(ForceType<AIStation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStation *)instance; }
 	template <> const AIStation *GetParam(ForceType<const AIStation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStation *)instance; }
 	template <> const AIStation &GetParam(ForceType<const AIStation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStation *)instance; }
-	template <> int Return<AIStation *>(HSQUIRRELVM vm, AIStation *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStation", res, NULL, DefSQDestructorCallback<AIStation>); return 1; }
+	template <> int Return<AIStation *>(HSQUIRRELVM vm, AIStation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStation", res, NULL, DefSQDestructorCallback<AIStation>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationRegister(Squirrel *engine) {

--- a/src/ai/api/ai_stationlist.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_stationlist.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIStationList &GetParam(ForceType<AIStationList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationList *)instance; }
 	template <> const AIStationList *GetParam(ForceType<const AIStationList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationList *)instance; }
 	template <> const AIStationList &GetParam(ForceType<const AIStationList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationList *)instance; }
-	template <> int Return<AIStationList *>(HSQUIRRELVM vm, AIStationList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationList", res, NULL, DefSQDestructorCallback<AIStationList>); return 1; }
+	template <> int Return<AIStationList *>(HSQUIRRELVM vm, AIStationList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationList", res, NULL, DefSQDestructorCallback<AIStationList>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationListRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AIVehicleStationList &GetParam(ForceType<AIVehicleStationList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleStationList *)instance; }
 	template <> const AIVehicleStationList *GetParam(ForceType<const AIVehicleStationList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleStationList *)instance; }
 	template <> const AIVehicleStationList &GetParam(ForceType<const AIVehicleStationList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleStationList *)instance; }
-	template <> int Return<AIVehicleStationList *>(HSQUIRRELVM vm, AIVehicleStationList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleStationList", res, NULL, DefSQDestructorCallback<AIVehicleStationList>); return 1; }
+	template <> int Return<AIVehicleStationList *>(HSQUIRRELVM vm, AIVehicleStationList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleStationList", res, NULL, DefSQDestructorCallback<AIVehicleStationList>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleStationListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_stationlist_valuator.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_stationlist_valuator.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIStationListLocation &GetParam(ForceType<AIStationListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListLocation *)instance; }
 	template <> const AIStationListLocation *GetParam(ForceType<const AIStationListLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationListLocation *)instance; }
 	template <> const AIStationListLocation &GetParam(ForceType<const AIStationListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListLocation *)instance; }
-	template <> int Return<AIStationListLocation *>(HSQUIRRELVM vm, AIStationListLocation *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListLocation", res, NULL, DefSQDestructorCallback<AIStationListLocation>); return 1; }
+	template <> int Return<AIStationListLocation *>(HSQUIRRELVM vm, AIStationListLocation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListLocation", res, NULL, DefSQDestructorCallback<AIStationListLocation>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationListLocationRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AIStationListCargoWaiting &GetParam(ForceType<AIStationListCargoWaiting &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListCargoWaiting *)instance; }
 	template <> const AIStationListCargoWaiting *GetParam(ForceType<const AIStationListCargoWaiting *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationListCargoWaiting *)instance; }
 	template <> const AIStationListCargoWaiting &GetParam(ForceType<const AIStationListCargoWaiting &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListCargoWaiting *)instance; }
-	template <> int Return<AIStationListCargoWaiting *>(HSQUIRRELVM vm, AIStationListCargoWaiting *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListCargoWaiting", res, NULL, DefSQDestructorCallback<AIStationListCargoWaiting>); return 1; }
+	template <> int Return<AIStationListCargoWaiting *>(HSQUIRRELVM vm, AIStationListCargoWaiting *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListCargoWaiting", res, NULL, DefSQDestructorCallback<AIStationListCargoWaiting>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationListCargoWaitingRegister(Squirrel *engine) {
@@ -44,7 +44,7 @@
 	template <> AIStationListCargoRating &GetParam(ForceType<AIStationListCargoRating &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListCargoRating *)instance; }
 	template <> const AIStationListCargoRating *GetParam(ForceType<const AIStationListCargoRating *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationListCargoRating *)instance; }
 	template <> const AIStationListCargoRating &GetParam(ForceType<const AIStationListCargoRating &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListCargoRating *)instance; }
-	template <> int Return<AIStationListCargoRating *>(HSQUIRRELVM vm, AIStationListCargoRating *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListCargoRating", res, NULL, DefSQDestructorCallback<AIStationListCargoRating>); return 1; }
+	template <> int Return<AIStationListCargoRating *>(HSQUIRRELVM vm, AIStationListCargoRating *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListCargoRating", res, NULL, DefSQDestructorCallback<AIStationListCargoRating>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationListCargoRatingRegister(Squirrel *engine) {
@@ -63,7 +63,7 @@
 	template <> AIStationListDistanceManhattanToTile &GetParam(ForceType<AIStationListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListDistanceManhattanToTile *)instance; }
 	template <> const AIStationListDistanceManhattanToTile *GetParam(ForceType<const AIStationListDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationListDistanceManhattanToTile *)instance; }
 	template <> const AIStationListDistanceManhattanToTile &GetParam(ForceType<const AIStationListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListDistanceManhattanToTile *)instance; }
-	template <> int Return<AIStationListDistanceManhattanToTile *>(HSQUIRRELVM vm, AIStationListDistanceManhattanToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AIStationListDistanceManhattanToTile>); return 1; }
+	template <> int Return<AIStationListDistanceManhattanToTile *>(HSQUIRRELVM vm, AIStationListDistanceManhattanToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AIStationListDistanceManhattanToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationListDistanceManhattanToTileRegister(Squirrel *engine) {
@@ -82,7 +82,7 @@
 	template <> AIStationListDistanceSquareToTile &GetParam(ForceType<AIStationListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListDistanceSquareToTile *)instance; }
 	template <> const AIStationListDistanceSquareToTile *GetParam(ForceType<const AIStationListDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationListDistanceSquareToTile *)instance; }
 	template <> const AIStationListDistanceSquareToTile &GetParam(ForceType<const AIStationListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationListDistanceSquareToTile *)instance; }
-	template <> int Return<AIStationListDistanceSquareToTile *>(HSQUIRRELVM vm, AIStationListDistanceSquareToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AIStationListDistanceSquareToTile>); return 1; }
+	template <> int Return<AIStationListDistanceSquareToTile *>(HSQUIRRELVM vm, AIStationListDistanceSquareToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AIStationListDistanceSquareToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationListDistanceSquareToTileRegister(Squirrel *engine) {

--- a/src/ai/api/ai_testmode.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_testmode.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AITestMode *>(HSQUIRRELVM vm, AITestMode *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITestMode", res, NULL, DefSQDestructorCallback<AITestMode>); return 1; }
+	template <> int Return<AITestMode *>(HSQUIRRELVM vm, AITestMode *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITestMode", res, NULL, DefSQDestructorCallback<AITestMode>); return 1; }
 }; // namespace SQConvert
 
 void SQAITestModeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_tile.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_tile.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AITile &GetParam(ForceType<AITile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITile *)instance; }
 	template <> const AITile *GetParam(ForceType<const AITile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITile *)instance; }
 	template <> const AITile &GetParam(ForceType<const AITile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITile *)instance; }
-	template <> int Return<AITile *>(HSQUIRRELVM vm, AITile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITile", res, NULL, DefSQDestructorCallback<AITile>); return 1; }
+	template <> int Return<AITile *>(HSQUIRRELVM vm, AITile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITile", res, NULL, DefSQDestructorCallback<AITile>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileRegister(Squirrel *engine) {

--- a/src/ai/api/ai_tilelist.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_tilelist.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AITileList *>(HSQUIRRELVM vm, AITileList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList", res, NULL, DefSQDestructorCallback<AITileList>); return 1; }
+	template <> int Return<AITileList *>(HSQUIRRELVM vm, AITileList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList", res, NULL, DefSQDestructorCallback<AITileList>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_tilelist_valuator.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_tilelist_valuator.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AITileListBuildable *>(HSQUIRRELVM vm, AITileListBuildable *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListBuildable", res, NULL, DefSQDestructorCallback<AITileListBuildable>); return 1; }
+	template <> int Return<AITileListBuildable *>(HSQUIRRELVM vm, AITileListBuildable *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListBuildable", res, NULL, DefSQDestructorCallback<AITileListBuildable>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListBuildableRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AITileListBuildableRectangle &GetParam(ForceType<AITileListBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildableRectangle *)instance; }
 	template <> const AITileListBuildableRectangle *GetParam(ForceType<const AITileListBuildableRectangle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListBuildableRectangle *)instance; }
 	template <> const AITileListBuildableRectangle &GetParam(ForceType<const AITileListBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildableRectangle *)instance; }
-	template <> int Return<AITileListBuildableRectangle *>(HSQUIRRELVM vm, AITileListBuildableRectangle *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListBuildableRectangle", res, NULL, DefSQDestructorCallback<AITileListBuildableRectangle>); return 1; }
+	template <> int Return<AITileListBuildableRectangle *>(HSQUIRRELVM vm, AITileListBuildableRectangle *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListBuildableRectangle", res, NULL, DefSQDestructorCallback<AITileListBuildableRectangle>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListBuildableRectangleRegister(Squirrel *engine) {
@@ -44,7 +44,7 @@
 	template <> AITileListSlope &GetParam(ForceType<AITileListSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListSlope *)instance; }
 	template <> const AITileListSlope *GetParam(ForceType<const AITileListSlope *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListSlope *)instance; }
 	template <> const AITileListSlope &GetParam(ForceType<const AITileListSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListSlope *)instance; }
-	template <> int Return<AITileListSlope *>(HSQUIRRELVM vm, AITileListSlope *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListSlope", res, NULL, DefSQDestructorCallback<AITileListSlope>); return 1; }
+	template <> int Return<AITileListSlope *>(HSQUIRRELVM vm, AITileListSlope *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListSlope", res, NULL, DefSQDestructorCallback<AITileListSlope>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListSlopeRegister(Squirrel *engine) {
@@ -63,7 +63,7 @@
 	template <> AITileListNeighbourRoadCount &GetParam(ForceType<AITileListNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListNeighbourRoadCount *)instance; }
 	template <> const AITileListNeighbourRoadCount *GetParam(ForceType<const AITileListNeighbourRoadCount *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListNeighbourRoadCount *)instance; }
 	template <> const AITileListNeighbourRoadCount &GetParam(ForceType<const AITileListNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListNeighbourRoadCount *)instance; }
-	template <> int Return<AITileListNeighbourRoadCount *>(HSQUIRRELVM vm, AITileListNeighbourRoadCount *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListNeighbourRoadCount", res, NULL, DefSQDestructorCallback<AITileListNeighbourRoadCount>); return 1; }
+	template <> int Return<AITileListNeighbourRoadCount *>(HSQUIRRELVM vm, AITileListNeighbourRoadCount *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListNeighbourRoadCount", res, NULL, DefSQDestructorCallback<AITileListNeighbourRoadCount>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListNeighbourRoadCountRegister(Squirrel *engine) {
@@ -82,7 +82,7 @@
 	template <> AITileListRoadTile &GetParam(ForceType<AITileListRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListRoadTile *)instance; }
 	template <> const AITileListRoadTile *GetParam(ForceType<const AITileListRoadTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListRoadTile *)instance; }
 	template <> const AITileListRoadTile &GetParam(ForceType<const AITileListRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListRoadTile *)instance; }
-	template <> int Return<AITileListRoadTile *>(HSQUIRRELVM vm, AITileListRoadTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListRoadTile", res, NULL, DefSQDestructorCallback<AITileListRoadTile>); return 1; }
+	template <> int Return<AITileListRoadTile *>(HSQUIRRELVM vm, AITileListRoadTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListRoadTile", res, NULL, DefSQDestructorCallback<AITileListRoadTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListRoadTileRegister(Squirrel *engine) {
@@ -101,7 +101,7 @@
 	template <> AITileListCargoAcceptance &GetParam(ForceType<AITileListCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListCargoAcceptance *)instance; }
 	template <> const AITileListCargoAcceptance *GetParam(ForceType<const AITileListCargoAcceptance *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListCargoAcceptance *)instance; }
 	template <> const AITileListCargoAcceptance &GetParam(ForceType<const AITileListCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListCargoAcceptance *)instance; }
-	template <> int Return<AITileListCargoAcceptance *>(HSQUIRRELVM vm, AITileListCargoAcceptance *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListCargoAcceptance", res, NULL, DefSQDestructorCallback<AITileListCargoAcceptance>); return 1; }
+	template <> int Return<AITileListCargoAcceptance *>(HSQUIRRELVM vm, AITileListCargoAcceptance *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListCargoAcceptance", res, NULL, DefSQDestructorCallback<AITileListCargoAcceptance>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListCargoAcceptanceRegister(Squirrel *engine) {
@@ -120,7 +120,7 @@
 	template <> AITileListDistanceManhattanToTile &GetParam(ForceType<AITileListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceManhattanToTile *)instance; }
 	template <> const AITileListDistanceManhattanToTile *GetParam(ForceType<const AITileListDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListDistanceManhattanToTile *)instance; }
 	template <> const AITileListDistanceManhattanToTile &GetParam(ForceType<const AITileListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceManhattanToTile *)instance; }
-	template <> int Return<AITileListDistanceManhattanToTile *>(HSQUIRRELVM vm, AITileListDistanceManhattanToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AITileListDistanceManhattanToTile>); return 1; }
+	template <> int Return<AITileListDistanceManhattanToTile *>(HSQUIRRELVM vm, AITileListDistanceManhattanToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AITileListDistanceManhattanToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListDistanceManhattanToTileRegister(Squirrel *engine) {
@@ -139,7 +139,7 @@
 	template <> AITileListDistanceSquareToTile &GetParam(ForceType<AITileListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceSquareToTile *)instance; }
 	template <> const AITileListDistanceSquareToTile *GetParam(ForceType<const AITileListDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileListDistanceSquareToTile *)instance; }
 	template <> const AITileListDistanceSquareToTile &GetParam(ForceType<const AITileListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceSquareToTile *)instance; }
-	template <> int Return<AITileListDistanceSquareToTile *>(HSQUIRRELVM vm, AITileListDistanceSquareToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AITileListDistanceSquareToTile>); return 1; }
+	template <> int Return<AITileListDistanceSquareToTile *>(HSQUIRRELVM vm, AITileListDistanceSquareToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AITileListDistanceSquareToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAITileListDistanceSquareToTileRegister(Squirrel *engine) {

--- a/src/ai/api/ai_town.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_town.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AITown *>(HSQUIRRELVM vm, AITown *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITown", res, NULL, DefSQDestructorCallback<AITown>); return 1; }
+	template <> int Return<AITown *>(HSQUIRRELVM vm, AITown *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITown", res, NULL, DefSQDestructorCallback<AITown>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownRegister(Squirrel *engine) {

--- a/src/ai/api/ai_townlist.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_townlist.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AITownList *>(HSQUIRRELVM vm, AITownList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownList", res, NULL, DefSQDestructorCallback<AITownList>); return 1; }
+	template <> int Return<AITownList *>(HSQUIRRELVM vm, AITownList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownList", res, NULL, DefSQDestructorCallback<AITownList>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_townlist_valuator.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_townlist_valuator.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AITownListRandomize &GetParam(ForceType<AITownListRandomize &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListRandomize *)instance; }
 	template <> const AITownListRandomize *GetParam(ForceType<const AITownListRandomize *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListRandomize *)instance; }
 	template <> const AITownListRandomize &GetParam(ForceType<const AITownListRandomize &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListRandomize *)instance; }
-	template <> int Return<AITownListRandomize *>(HSQUIRRELVM vm, AITownListRandomize *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListRandomize", res, NULL, DefSQDestructorCallback<AITownListRandomize>); return 1; }
+	template <> int Return<AITownListRandomize *>(HSQUIRRELVM vm, AITownListRandomize *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListRandomize", res, NULL, DefSQDestructorCallback<AITownListRandomize>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownListRandomizeRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AITownListPopulation &GetParam(ForceType<AITownListPopulation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListPopulation *)instance; }
 	template <> const AITownListPopulation *GetParam(ForceType<const AITownListPopulation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListPopulation *)instance; }
 	template <> const AITownListPopulation &GetParam(ForceType<const AITownListPopulation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListPopulation *)instance; }
-	template <> int Return<AITownListPopulation *>(HSQUIRRELVM vm, AITownListPopulation *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListPopulation", res, NULL, DefSQDestructorCallback<AITownListPopulation>); return 1; }
+	template <> int Return<AITownListPopulation *>(HSQUIRRELVM vm, AITownListPopulation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListPopulation", res, NULL, DefSQDestructorCallback<AITownListPopulation>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownListPopulationRegister(Squirrel *engine) {
@@ -44,7 +44,7 @@
 	template <> AITownListLocation &GetParam(ForceType<AITownListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListLocation *)instance; }
 	template <> const AITownListLocation *GetParam(ForceType<const AITownListLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListLocation *)instance; }
 	template <> const AITownListLocation &GetParam(ForceType<const AITownListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListLocation *)instance; }
-	template <> int Return<AITownListLocation *>(HSQUIRRELVM vm, AITownListLocation *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListLocation", res, NULL, DefSQDestructorCallback<AITownListLocation>); return 1; }
+	template <> int Return<AITownListLocation *>(HSQUIRRELVM vm, AITownListLocation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListLocation", res, NULL, DefSQDestructorCallback<AITownListLocation>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownListLocationRegister(Squirrel *engine) {
@@ -63,7 +63,7 @@
 	template <> AITownListDistanceManhattanToTile &GetParam(ForceType<AITownListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListDistanceManhattanToTile *)instance; }
 	template <> const AITownListDistanceManhattanToTile *GetParam(ForceType<const AITownListDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListDistanceManhattanToTile *)instance; }
 	template <> const AITownListDistanceManhattanToTile &GetParam(ForceType<const AITownListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListDistanceManhattanToTile *)instance; }
-	template <> int Return<AITownListDistanceManhattanToTile *>(HSQUIRRELVM vm, AITownListDistanceManhattanToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AITownListDistanceManhattanToTile>); return 1; }
+	template <> int Return<AITownListDistanceManhattanToTile *>(HSQUIRRELVM vm, AITownListDistanceManhattanToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AITownListDistanceManhattanToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownListDistanceManhattanToTileRegister(Squirrel *engine) {
@@ -82,7 +82,7 @@
 	template <> AITownListDistanceSquareToTile &GetParam(ForceType<AITownListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListDistanceSquareToTile *)instance; }
 	template <> const AITownListDistanceSquareToTile *GetParam(ForceType<const AITownListDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITownListDistanceSquareToTile *)instance; }
 	template <> const AITownListDistanceSquareToTile &GetParam(ForceType<const AITownListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITownListDistanceSquareToTile *)instance; }
-	template <> int Return<AITownListDistanceSquareToTile *>(HSQUIRRELVM vm, AITownListDistanceSquareToTile *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AITownListDistanceSquareToTile>); return 1; }
+	template <> int Return<AITownListDistanceSquareToTile *>(HSQUIRRELVM vm, AITownListDistanceSquareToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITownListDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AITownListDistanceSquareToTile>); return 1; }
 }; // namespace SQConvert
 
 void SQAITownListDistanceSquareToTileRegister(Squirrel *engine) {

--- a/src/ai/api/ai_transactionmode.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_transactionmode.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AITransactionMode *>(HSQUIRRELVM vm, AITransactionMode *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITransactionMode", res, NULL, DefSQDestructorCallback<AITransactionMode>); return 1; }
+	template <> int Return<AITransactionMode *>(HSQUIRRELVM vm, AITransactionMode *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITransactionMode", res, NULL, DefSQDestructorCallback<AITransactionMode>); return 1; }
 }; // namespace SQConvert
 
 void SQAITransactionModeRegister(Squirrel *engine) {

--- a/src/ai/api/ai_vehicle.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_vehicle.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	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; }
-	template <> int Return<AIVehicle *>(HSQUIRRELVM vm, AIVehicle *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicle", res, NULL, DefSQDestructorCallback<AIVehicle>); return 1; }
+	template <> int Return<AIVehicle *>(HSQUIRRELVM vm, AIVehicle *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicle", res, NULL, DefSQDestructorCallback<AIVehicle>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleRegister(Squirrel *engine) {

--- a/src/ai/api/ai_vehiclelist.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_vehiclelist.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIVehicleList &GetParam(ForceType<AIVehicleList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList *)instance; }
 	template <> const AIVehicleList *GetParam(ForceType<const AIVehicleList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList *)instance; }
 	template <> const AIVehicleList &GetParam(ForceType<const AIVehicleList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList *)instance; }
-	template <> int Return<AIVehicleList *>(HSQUIRRELVM vm, AIVehicleList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList", res, NULL, DefSQDestructorCallback<AIVehicleList>); return 1; }
+	template <> int Return<AIVehicleList *>(HSQUIRRELVM vm, AIVehicleList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList", res, NULL, DefSQDestructorCallback<AIVehicleList>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AIStationVehicleList &GetParam(ForceType<AIStationVehicleList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationVehicleList *)instance; }
 	template <> const AIStationVehicleList *GetParam(ForceType<const AIStationVehicleList *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIStationVehicleList *)instance; }
 	template <> const AIStationVehicleList &GetParam(ForceType<const AIStationVehicleList &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIStationVehicleList *)instance; }
-	template <> int Return<AIStationVehicleList *>(HSQUIRRELVM vm, AIStationVehicleList *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationVehicleList", res, NULL, DefSQDestructorCallback<AIStationVehicleList>); return 1; }
+	template <> int Return<AIStationVehicleList *>(HSQUIRRELVM vm, AIStationVehicleList *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIStationVehicleList", res, NULL, DefSQDestructorCallback<AIStationVehicleList>); return 1; }
 }; // namespace SQConvert
 
 void SQAIStationVehicleListRegister(Squirrel *engine) {

--- a/src/ai/api/ai_vehiclelist_valuator.hpp.sq	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/ai_vehiclelist_valuator.hpp.sq	Thu Jul 19 19:42:54 2007 +0000
@@ -6,7 +6,7 @@
 	template <> AIVehicleListLocation &GetParam(ForceType<AIVehicleListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListLocation *)instance; }
 	template <> const AIVehicleListLocation *GetParam(ForceType<const AIVehicleListLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListLocation *)instance; }
 	template <> const AIVehicleListLocation &GetParam(ForceType<const AIVehicleListLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListLocation *)instance; }
-	template <> int Return<AIVehicleListLocation *>(HSQUIRRELVM vm, AIVehicleListLocation *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListLocation", res, NULL, DefSQDestructorCallback<AIVehicleListLocation>); return 1; }
+	template <> int Return<AIVehicleListLocation *>(HSQUIRRELVM vm, AIVehicleListLocation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListLocation", res, NULL, DefSQDestructorCallback<AIVehicleListLocation>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListLocationRegister(Squirrel *engine) {
@@ -25,7 +25,7 @@
 	template <> AIVehicleListEngineType &GetParam(ForceType<AIVehicleListEngineType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListEngineType *)instance; }
 	template <> const AIVehicleListEngineType *GetParam(ForceType<const AIVehicleListEngineType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListEngineType *)instance; }
 	template <> const AIVehicleListEngineType &GetParam(ForceType<const AIVehicleListEngineType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListEngineType *)instance; }
-	template <> int Return<AIVehicleListEngineType *>(HSQUIRRELVM vm, AIVehicleListEngineType *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListEngineType", res, NULL, DefSQDestructorCallback<AIVehicleListEngineType>); return 1; }
+	template <> int Return<AIVehicleListEngineType *>(HSQUIRRELVM vm, AIVehicleListEngineType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListEngineType", res, NULL, DefSQDestructorCallback<AIVehicleListEngineType>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListEngineTypeRegister(Squirrel *engine) {
@@ -44,7 +44,7 @@
 	template <> AIVehicleListUnitNumber &GetParam(ForceType<AIVehicleListUnitNumber &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListUnitNumber *)instance; }
 	template <> const AIVehicleListUnitNumber *GetParam(ForceType<const AIVehicleListUnitNumber *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListUnitNumber *)instance; }
 	template <> const AIVehicleListUnitNumber &GetParam(ForceType<const AIVehicleListUnitNumber &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListUnitNumber *)instance; }
-	template <> int Return<AIVehicleListUnitNumber *>(HSQUIRRELVM vm, AIVehicleListUnitNumber *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListUnitNumber", res, NULL, DefSQDestructorCallback<AIVehicleListUnitNumber>); return 1; }
+	template <> int Return<AIVehicleListUnitNumber *>(HSQUIRRELVM vm, AIVehicleListUnitNumber *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListUnitNumber", res, NULL, DefSQDestructorCallback<AIVehicleListUnitNumber>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListUnitNumberRegister(Squirrel *engine) {
@@ -63,7 +63,7 @@
 	template <> AIVehicleListAge &GetParam(ForceType<AIVehicleListAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListAge *)instance; }
 	template <> const AIVehicleListAge *GetParam(ForceType<const AIVehicleListAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListAge *)instance; }
 	template <> const AIVehicleListAge &GetParam(ForceType<const AIVehicleListAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListAge *)instance; }
-	template <> int Return<AIVehicleListAge *>(HSQUIRRELVM vm, AIVehicleListAge *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListAge", res, NULL, DefSQDestructorCallback<AIVehicleListAge>); return 1; }
+	template <> int Return<AIVehicleListAge *>(HSQUIRRELVM vm, AIVehicleListAge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListAge", res, NULL, DefSQDestructorCallback<AIVehicleListAge>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListAgeRegister(Squirrel *engine) {
@@ -82,7 +82,7 @@
 	template <> AIVehicleListMaxAge &GetParam(ForceType<AIVehicleListMaxAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListMaxAge *)instance; }
 	template <> const AIVehicleListMaxAge *GetParam(ForceType<const AIVehicleListMaxAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListMaxAge *)instance; }
 	template <> const AIVehicleListMaxAge &GetParam(ForceType<const AIVehicleListMaxAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListMaxAge *)instance; }
-	template <> int Return<AIVehicleListMaxAge *>(HSQUIRRELVM vm, AIVehicleListMaxAge *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListMaxAge", res, NULL, DefSQDestructorCallback<AIVehicleListMaxAge>); return 1; }
+	template <> int Return<AIVehicleListMaxAge *>(HSQUIRRELVM vm, AIVehicleListMaxAge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListMaxAge", res, NULL, DefSQDestructorCallback<AIVehicleListMaxAge>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListMaxAgeRegister(Squirrel *engine) {
@@ -101,7 +101,7 @@
 	template <> AIVehicleListAgeLeft &GetParam(ForceType<AIVehicleListAgeLeft &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListAgeLeft *)instance; }
 	template <> const AIVehicleListAgeLeft *GetParam(ForceType<const AIVehicleListAgeLeft *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListAgeLeft *)instance; }
 	template <> const AIVehicleListAgeLeft &GetParam(ForceType<const AIVehicleListAgeLeft &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListAgeLeft *)instance; }
-	template <> int Return<AIVehicleListAgeLeft *>(HSQUIRRELVM vm, AIVehicleListAgeLeft *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListAgeLeft", res, NULL, DefSQDestructorCallback<AIVehicleListAgeLeft>); return 1; }
+	template <> int Return<AIVehicleListAgeLeft *>(HSQUIRRELVM vm, AIVehicleListAgeLeft *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListAgeLeft", res, NULL, DefSQDestructorCallback<AIVehicleListAgeLeft>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListAgeLeftRegister(Squirrel *engine) {
@@ -120,7 +120,7 @@
 	template <> AIVehicleListProfitThisYear &GetParam(ForceType<AIVehicleListProfitThisYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListProfitThisYear *)instance; }
 	template <> const AIVehicleListProfitThisYear *GetParam(ForceType<const AIVehicleListProfitThisYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListProfitThisYear *)instance; }
 	template <> const AIVehicleListProfitThisYear &GetParam(ForceType<const AIVehicleListProfitThisYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListProfitThisYear *)instance; }
-	template <> int Return<AIVehicleListProfitThisYear *>(HSQUIRRELVM vm, AIVehicleListProfitThisYear *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListProfitThisYear", res, NULL, DefSQDestructorCallback<AIVehicleListProfitThisYear>); return 1; }
+	template <> int Return<AIVehicleListProfitThisYear *>(HSQUIRRELVM vm, AIVehicleListProfitThisYear *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListProfitThisYear", res, NULL, DefSQDestructorCallback<AIVehicleListProfitThisYear>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListProfitThisYearRegister(Squirrel *engine) {
@@ -139,7 +139,7 @@
 	template <> AIVehicleListProfitLastYear &GetParam(ForceType<AIVehicleListProfitLastYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListProfitLastYear *)instance; }
 	template <> const AIVehicleListProfitLastYear *GetParam(ForceType<const AIVehicleListProfitLastYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleListProfitLastYear *)instance; }
 	template <> const AIVehicleListProfitLastYear &GetParam(ForceType<const AIVehicleListProfitLastYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleListProfitLastYear *)instance; }
-	template <> int Return<AIVehicleListProfitLastYear *>(HSQUIRRELVM vm, AIVehicleListProfitLastYear *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListProfitLastYear", res, NULL, DefSQDestructorCallback<AIVehicleListProfitLastYear>); return 1; }
+	template <> int Return<AIVehicleListProfitLastYear *>(HSQUIRRELVM vm, AIVehicleListProfitLastYear *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleListProfitLastYear", res, NULL, DefSQDestructorCallback<AIVehicleListProfitLastYear>); return 1; }
 }; // namespace SQConvert
 
 void SQAIVehicleListProfitLastYearRegister(Squirrel *engine) {

--- a/src/ai/api/squirrel_export.awk	Thu Jul 19 17:13:38 2007 +0000
+++ b/src/ai/api/squirrel_export.awk	Thu Jul 19 19:42:54 2007 +0000
@@ -21,7 +21,7 @@
 	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; }"
-	print "	template <> int Return<" name " *>(HSQUIRRELVM vm, " name " *res) { res->AddRef(); Squirrel::CreateClassInstanceVM(vm, \"" name "\", res, NULL, DefSQDestructorCallback<" name ">); return 1; }"
+	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 {