(svn r9629) [NoAI] -Codechange: move the squirrel export functions out of the API header files.
--- a/bin/ai/regression/completeness.sh Sat Apr 14 21:01:44 2007 +0000
+++ b/bin/ai/regression/completeness.sh Sat Apr 14 21:57:44 2007 +0000
@@ -35,7 +35,7 @@
}
' | sort | uniq > tmp.in_regression
-grep 'DefSQ.*Method' ../src/ai/api/*.hpp | grep -v '::GetClassName' | sed 's/^[^,]*, &//g;s/,[^,]*//g' | sort > tmp.in_api
+grep 'DefSQ.*Method' ../src/ai/api/*.hpp.sq | grep -v '::GetClassName' | sed 's/^[^,]*, &//g;s/,[^,]*//g' | sort > tmp.in_api
diff -u tmp.in_regression tmp.in_api | grep -v '^+++' | grep '^+' | sed 's/^+//'
--- a/src/ai/ai_squirrel.cpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/ai_squirrel.cpp Sat Apr 14 21:57:44 2007 +0000
@@ -21,28 +21,28 @@
/* 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"
-#include "api/ai_company.hpp"
-#include "api/ai_controller.hpp"
-#include "api/ai_execmode.hpp"
-#include "api/ai_industry.hpp"
-#include "api/ai_list.hpp"
-#include "api/ai_map.hpp"
-#include "api/ai_order.hpp"
-#include "api/ai_road.hpp"
-#include "api/ai_settings.hpp"
-#include "api/ai_sign.hpp"
-#include "api/ai_testmode.hpp"
-#include "api/ai_tilelist.hpp"
-#include "api/ai_tilelist_valuator.hpp"
-#include "api/ai_town.hpp"
-#include "api/ai_townlist.hpp"
-#include "api/ai_townlist_valuator.hpp"
-#include "api/ai_transactionmode.hpp"
-#include "api/ai_vehicle.hpp"
+#include "api/ai_abstractlist.hpp.sq"
+#include "api/ai_accounting.hpp.sq"
+#include "api/ai_base.hpp.sq"
+#include "api/ai_cargo.hpp.sq"
+#include "api/ai_company.hpp.sq"
+#include "api/ai_controller.hpp.sq"
+#include "api/ai_execmode.hpp.sq"
+#include "api/ai_industry.hpp.sq"
+#include "api/ai_list.hpp.sq"
+#include "api/ai_map.hpp.sq"
+#include "api/ai_order.hpp.sq"
+#include "api/ai_road.hpp.sq"
+#include "api/ai_settings.hpp.sq"
+#include "api/ai_sign.hpp.sq"
+#include "api/ai_testmode.hpp.sq"
+#include "api/ai_tilelist.hpp.sq"
+#include "api/ai_tilelist_valuator.hpp.sq"
+#include "api/ai_town.hpp.sq"
+#include "api/ai_townlist.hpp.sq"
+#include "api/ai_townlist_valuator.hpp.sq"
+#include "api/ai_transactionmode.hpp.sq"
+#include "api/ai_vehicle.hpp.sq"
#undef DEFINE_SQUIRREL_CLASS
static FSquirrel iFSquirrel; ///< Tell the AI-core that we have an AI with which we like to play.
--- a/src/ai/api/ai_abstractlist.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_abstractlist.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -195,50 +195,4 @@
void Valuate(const AIAbstractList::Valuator &proc);
};
-#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 <> 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) {
- DefSQClass <AIAbstractList> SQAIAbstractList("AIAbstractList");
- SQAIAbstractList.PreRegister(engine);
- SQAIAbstractList.AddConstructor(engine);
-
- SQAIAbstractList.DefSQStaticMethod(engine, &AIAbstractList::GetClassName, "GetClassName", 1, "x");
-
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Clear, "Clear", 1, "x");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasItem, "HasItem", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Begin, "Begin", 1, "x");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Next, "Next", 1, "x");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::IsEmpty, "IsEmpty", 1, "x");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasNext, "HasNext", 1, "x");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Count, "Count", 1, "x");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::GetValue, "GetValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::SortByItem, "SortByItem", 2, "xb");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::SortByValue, "SortByValue", 2, "xb");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveAboveValue, "RemoveAboveValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBelowValue, "RemoveBelowValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBetweenValue, "RemoveBetweenValue", 3, "xii");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveValue, "RemoveValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepAboveValue, "KeepAboveValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBelowValue, "KeepBelowValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBetweenValue, "KeepBetweenValue", 3, "xii");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepValue, "KeepValue", 2, "xi");
- SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Valuate, "Valuate", 2, "xx");
-
- SQAIAbstractList.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_LIST_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_abstractlist.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,45 @@
+#include "ai_abstractlist.hpp"
+
+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 <> 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) {
+ DefSQClass <AIAbstractList> SQAIAbstractList("AIAbstractList");
+ SQAIAbstractList.PreRegister(engine);
+ SQAIAbstractList.AddConstructor(engine);
+
+ SQAIAbstractList.DefSQStaticMethod(engine, &AIAbstractList::GetClassName, "GetClassName", 1, "x");
+
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Clear, "Clear", 1, "x");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasItem, "HasItem", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Begin, "Begin", 1, "x");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Next, "Next", 1, "x");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::IsEmpty, "IsEmpty", 1, "x");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::HasNext, "HasNext", 1, "x");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Count, "Count", 1, "x");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::GetValue, "GetValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::SortByItem, "SortByItem", 2, "xb");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::SortByValue, "SortByValue", 2, "xb");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveAboveValue, "RemoveAboveValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBelowValue, "RemoveBelowValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveBetweenValue, "RemoveBetweenValue", 3, "xii");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::RemoveValue, "RemoveValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepAboveValue, "KeepAboveValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBelowValue, "KeepBelowValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepBetweenValue, "KeepBetweenValue", 3, "xii");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::KeepValue, "KeepValue", 2, "xi");
+ SQAIAbstractList.DefSQMethod(engine, &AIAbstractList::Valuate, "Valuate", 2, "xx");
+
+ SQAIAbstractList.PostRegister(engine);
+}
--- a/src/ai/api/ai_accounting.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_accounting.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -51,27 +51,4 @@
void ResetCosts();
};
-#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 <> 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) {
- DefSQClass <AIAccounting> SQAIAccounting("AIAccounting");
- SQAIAccounting.PreRegister(engine);
- SQAIAccounting.AddConstructor(engine);
-
- SQAIAccounting.DefSQStaticMethod(engine, &AIAccounting::GetClassName, "GetClassName", 1, "x");
-
- SQAIAccounting.DefSQMethod(engine, &AIAccounting::GetCosts, "GetCosts", 1, "x");
- SQAIAccounting.DefSQMethod(engine, &AIAccounting::ResetCosts, "ResetCosts", 1, "x");
-
- SQAIAccounting.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_ACCOUNTING_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_accounting.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,22 @@
+#include "ai_accounting.hpp"
+
+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 <> 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) {
+ DefSQClass <AIAccounting> SQAIAccounting("AIAccounting");
+ SQAIAccounting.PreRegister(engine);
+ SQAIAccounting.AddConstructor(engine);
+
+ SQAIAccounting.DefSQStaticMethod(engine, &AIAccounting::GetClassName, "GetClassName", 1, "x");
+
+ SQAIAccounting.DefSQMethod(engine, &AIAccounting::GetCosts, "GetCosts", 1, "x");
+ SQAIAccounting.DefSQMethod(engine, &AIAccounting::ResetCosts, "ResetCosts", 1, "x");
+
+ SQAIAccounting.PostRegister(engine);
+}
--- a/src/ai/api/ai_base.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_base.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -46,28 +46,4 @@
bool Chance(uint out, uint max);
};
-#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 <> 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) {
- DefSQClass <AIBase> SQAIBase("AIBase");
- SQAIBase.PreRegister(engine);
- SQAIBase.AddConstructor(engine);
-
- SQAIBase.DefSQStaticMethod(engine, &AIBase::GetClassName, "GetClassName", 1, "x");
-
- SQAIBase.DefSQMethod(engine, &AIBase::Rand, "Rand", 1, "x");
- SQAIBase.DefSQMethod(engine, &AIBase::RandRange, "RandRange", 2, "xi");
- SQAIBase.DefSQMethod(engine, &AIBase::Chance, "Chance", 3, "xii");
-
- SQAIBase.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_BASE_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_base.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,23 @@
+#include "ai_base.hpp"
+
+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 <> 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) {
+ DefSQClass <AIBase> SQAIBase("AIBase");
+ SQAIBase.PreRegister(engine);
+ SQAIBase.AddConstructor(engine);
+
+ SQAIBase.DefSQStaticMethod(engine, &AIBase::GetClassName, "GetClassName", 1, "x");
+
+ SQAIBase.DefSQMethod(engine, &AIBase::Rand, "Rand", 1, "x");
+ SQAIBase.DefSQMethod(engine, &AIBase::RandRange, "RandRange", 2, "xi");
+ SQAIBase.DefSQMethod(engine, &AIBase::Chance, "Chance", 3, "xii");
+
+ SQAIBase.PostRegister(engine);
+}
--- a/src/ai/api/ai_cargo.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_cargo.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -50,29 +50,4 @@
int32 GetCargoIncome(uint32 distance, uint32 days_in_transit, CargoID cargo_type);
};
-#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 <> 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) {
- DefSQClass <AICargo> SQAICargo("AICargo");
- SQAICargo.PreRegister(engine);
- SQAICargo.AddConstructor(engine);
-
- SQAICargo.DefSQStaticMethod(engine, &AICargo::GetClassName, "GetClassName", 1, "x");
- SQAICargo.DefSQStaticMethod(engine, &AICargo::IsValidCargo, "IsValidCargo", 2, "xi");
-
- SQAICargo.DefSQMethod(engine, &AICargo::GetCargoLabel, "GetCargoLabel", 2, "xi");
- SQAICargo.DefSQMethod(engine, &AICargo::IsFreight, "IsFreight", 2, "xi");
- SQAICargo.DefSQMethod(engine, &AICargo::GetCargoIncome, "GetCargoIncome", 4, "xiii");
-
- SQAICargo.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_CARGO_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_cargo.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,24 @@
+#include "ai_cargo.hpp"
+
+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 <> 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) {
+ DefSQClass <AICargo> SQAICargo("AICargo");
+ SQAICargo.PreRegister(engine);
+ SQAICargo.AddConstructor(engine);
+
+ SQAICargo.DefSQStaticMethod(engine, &AICargo::GetClassName, "GetClassName", 1, "x");
+ SQAICargo.DefSQStaticMethod(engine, &AICargo::IsValidCargo, "IsValidCargo", 2, "xi");
+
+ SQAICargo.DefSQMethod(engine, &AICargo::GetCargoLabel, "GetCargoLabel", 2, "xi");
+ SQAICargo.DefSQMethod(engine, &AICargo::IsFreight, "IsFreight", 2, "xi");
+ SQAICargo.DefSQMethod(engine, &AICargo::GetCargoIncome, "GetCargoIncome", 4, "xiii");
+
+ SQAICargo.PostRegister(engine);
+}
--- a/src/ai/api/ai_company.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_company.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -94,35 +94,4 @@
bool SetLoanAmount(int32 loan);
};
-#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 <> 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) {
- DefSQClass <AICompany> SQAICompany("AICompany");
- SQAICompany.PreRegister(engine);
- SQAICompany.AddConstructor(engine);
-
- SQAICompany.DefSQStaticMethod(engine, &AICompany::GetClassName, "GetClassName", 1, "x");
-
- SQAICompany.DefSQMethod(engine, &AICompany::SetCompanyName, "SetCompanyName", 2, "xs");
- SQAICompany.DefSQMethod(engine, &AICompany::GetCompanyName, "GetCompanyName", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::SetPresidentName, "SetPresidentName", 2, "xs");
- SQAICompany.DefSQMethod(engine, &AICompany::GetPresidentName, "GetPresidentName", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::GetCompanyValue, "GetCompanyValue", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::GetBankBalance, "GetBankBalance", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::GetLoanAmount, "GetLoanAmount", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::GetMaxLoanAmount, "GetMaxLoanAmount", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::GetLoanInterval, "GetLoanInterval", 1, "x");
- SQAICompany.DefSQMethod(engine, &AICompany::SetLoanAmount, "SetLoanAmount", 2, "xi");
-
- SQAICompany.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_COMPANY_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_company.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,30 @@
+#include "ai_company.hpp"
+
+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 <> 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) {
+ DefSQClass <AICompany> SQAICompany("AICompany");
+ SQAICompany.PreRegister(engine);
+ SQAICompany.AddConstructor(engine);
+
+ SQAICompany.DefSQStaticMethod(engine, &AICompany::GetClassName, "GetClassName", 1, "x");
+
+ SQAICompany.DefSQMethod(engine, &AICompany::SetCompanyName, "SetCompanyName", 2, "xs");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetCompanyName, "GetCompanyName", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::SetPresidentName, "SetPresidentName", 2, "xs");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetPresidentName, "GetPresidentName", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetCompanyValue, "GetCompanyValue", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetBankBalance, "GetBankBalance", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetLoanAmount, "GetLoanAmount", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetMaxLoanAmount, "GetMaxLoanAmount", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::GetLoanInterval, "GetLoanInterval", 1, "x");
+ SQAICompany.DefSQMethod(engine, &AICompany::SetLoanAmount, "SetLoanAmount", 2, "xi");
+
+ SQAICompany.PostRegister(engine);
+}
--- a/src/ai/api/ai_controller.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_controller.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -73,25 +73,3 @@
};
#endif /* AI_CONTROLLER_HPP */
-
-/*
- * The next part of the code is outside of the multiple inclusions
- * protection. This is done because the Squirrel code needs the
- * AIController class declaration to make the Squirrel registration
- * functions. So in the first include DEFINE_SQUIRREL_CLASS is not
- * defined, but in the second one it will when included from the
- * Squirrel AI implementation.
- * All other instances that include this header twice must not have
- * set DEFINE_SQUIRREL_CLASS, so this part will not be included
- * twice under those circumstances.
- */
-
-#ifdef DEFINE_SQUIRREL_CLASS
-void SQAIControllerRegister(Squirrel *engine) {
- DefSQClass <AIControllerSquirrel> SQAIController("AIController");
- SQAIController.PreRegister(engine);
- SQAIController.DefSQMethod(engine, &AIControllerSquirrel::GetTick, "GetTick");
- SQAIController.DefSQMethod(engine, &AIControllerSquirrel::Sleep, "Sleep");
- SQAIController.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_controller.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,9 @@
+#include "ai_controller.hpp"
+
+void SQAIControllerRegister(Squirrel *engine) {
+ DefSQClass <AIControllerSquirrel> SQAIController("AIController");
+ SQAIController.PreRegister(engine);
+ SQAIController.DefSQMethod(engine, &AIControllerSquirrel::GetTick, "GetTick");
+ SQAIController.DefSQMethod(engine, &AIControllerSquirrel::Sleep, "Sleep");
+ SQAIController.PostRegister(engine);
+}
--- a/src/ai/api/ai_execmode.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_execmode.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -45,24 +45,4 @@
~AIExecMode();
};
-#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 <> 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) {
- DefSQClass <AIExecMode> SQAIExecMode("AIExecMode");
- SQAIExecMode.PreRegister(engine);
- SQAIExecMode.AddConstructor(engine);
-
- SQAIExecMode.DefSQStaticMethod(engine, &AIExecMode::GetClassName, "GetClassName", 1, "x");
-
- SQAIExecMode.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_EXECMODE_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_execmode.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,19 @@
+#include "ai_execmode.hpp"
+
+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 <> 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) {
+ DefSQClass <AIExecMode> SQAIExecMode("AIExecMode");
+ SQAIExecMode.PreRegister(engine);
+ SQAIExecMode.AddConstructor(engine);
+
+ SQAIExecMode.DefSQStaticMethod(engine, &AIExecMode::GetClassName, "GetClassName", 1, "x");
+
+ SQAIExecMode.PostRegister(engine);
+}
--- a/src/ai/api/ai_industry.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_industry.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -59,30 +59,4 @@
TileIndex GetLocation(IndustryID industry_id);
};
-#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 <> 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) {
- DefSQClass <AIIndustry> SQAIIndustry("AIIndustry");
- SQAIIndustry.PreRegister(engine);
- SQAIIndustry.AddConstructor(engine);
-
- SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetClassName, "GetClassName", 1, "x");
- SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::IsValidIndustry, "IsValidIndustry", 2, "xi");
-
- SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetMaxIndustryID, "GetMaxIndustryID", 1, "x");
- SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetIndustryCount, "GetIndustryCount", 1, "x");
- SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetName, "GetName", 2, "xi");
- SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetLocation, "GetLocation", 2, "xi");
-
- SQAIIndustry.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_INDUSTRY_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_industry.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,25 @@
+#include "ai_industry.hpp"
+
+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 <> 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) {
+ DefSQClass <AIIndustry> SQAIIndustry("AIIndustry");
+ SQAIIndustry.PreRegister(engine);
+ SQAIIndustry.AddConstructor(engine);
+
+ SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::GetClassName, "GetClassName", 1, "x");
+ SQAIIndustry.DefSQStaticMethod(engine, &AIIndustry::IsValidIndustry, "IsValidIndustry", 2, "xi");
+
+ SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetMaxIndustryID, "GetMaxIndustryID", 1, "x");
+ SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetIndustryCount, "GetIndustryCount", 1, "x");
+ SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetName, "GetName", 2, "xi");
+ SQAIIndustry.DefSQMethod(engine, &AIIndustry::GetLocation, "GetLocation", 2, "xi");
+
+ SQAIIndustry.PostRegister(engine);
+}
--- a/src/ai/api/ai_list.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_list.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -31,27 +31,4 @@
void RemoveItem(int32 item);
};
-#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 <> 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) {
- DefSQClass <AIList> SQAIList("AIList");
- SQAIList.PreRegister(engine, "AIAbstractList");
- SQAIList.AddConstructor(engine);
-
- 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.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_LIST_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_list.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,22 @@
+#include "ai_list.hpp"
+
+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 <> 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) {
+ DefSQClass <AIList> SQAIList("AIList");
+ SQAIList.PreRegister(engine, "AIAbstractList");
+ SQAIList.AddConstructor(engine);
+
+ 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.PostRegister(engine);
+}
--- a/src/ai/api/ai_map.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_map.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -125,37 +125,4 @@
bool DemolishTile(TileIndex t);
};
-#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 <> 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) {
- DefSQClass <AIMap> SQAIMap("AIMap");
- SQAIMap.PreRegister(engine);
- SQAIMap.AddConstructor(engine);
-
- SQAIMap.DefSQStaticMethod(engine, &AIMap::GetClassName, "GetClassName", 1, "x");
-
- SQAIMap.DefSQMethod(engine, &AIMap::IsValidTile, "IsValidTile", 2, "xi");
- SQAIMap.DefSQMethod(engine, &AIMap::GetMapSize, "GetMapSize", 1, "x");
- SQAIMap.DefSQMethod(engine, &AIMap::GetMapSizeX, "GetMapSizeX", 1, "x");
- SQAIMap.DefSQMethod(engine, &AIMap::GetMapSizeY, "GetMapSizeY", 1, "x");
- SQAIMap.DefSQMethod(engine, &AIMap::GetTileX, "GetTileX", 2, "xi");
- SQAIMap.DefSQMethod(engine, &AIMap::GetTileY, "GetTileY", 2, "xi");
- SQAIMap.DefSQMethod(engine, &AIMap::GetTileIndex, "GetTileIndex", 3, "xii");
- SQAIMap.DefSQMethod(engine, &AIMap::DistanceManhattan, "DistanceManhattan", 3, "xii");
- SQAIMap.DefSQMethod(engine, &AIMap::DistanceMax, "DistanceMax", 3, "xii");
- SQAIMap.DefSQMethod(engine, &AIMap::DistanceSquare, "DistanceSquare", 3, "xii");
- SQAIMap.DefSQMethod(engine, &AIMap::DistanceFromEdge, "DistanceFromEdge", 2, "xi");
- SQAIMap.DefSQMethod(engine, &AIMap::DemolishTile, "DemolishTile", 2, "xi");
-
- SQAIMap.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_MAP_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_map.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,32 @@
+#include "ai_map.hpp"
+
+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 <> 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) {
+ DefSQClass <AIMap> SQAIMap("AIMap");
+ SQAIMap.PreRegister(engine);
+ SQAIMap.AddConstructor(engine);
+
+ SQAIMap.DefSQStaticMethod(engine, &AIMap::GetClassName, "GetClassName", 1, "x");
+
+ SQAIMap.DefSQMethod(engine, &AIMap::IsValidTile, "IsValidTile", 2, "xi");
+ SQAIMap.DefSQMethod(engine, &AIMap::GetMapSize, "GetMapSize", 1, "x");
+ SQAIMap.DefSQMethod(engine, &AIMap::GetMapSizeX, "GetMapSizeX", 1, "x");
+ SQAIMap.DefSQMethod(engine, &AIMap::GetMapSizeY, "GetMapSizeY", 1, "x");
+ SQAIMap.DefSQMethod(engine, &AIMap::GetTileX, "GetTileX", 2, "xi");
+ SQAIMap.DefSQMethod(engine, &AIMap::GetTileY, "GetTileY", 2, "xi");
+ SQAIMap.DefSQMethod(engine, &AIMap::GetTileIndex, "GetTileIndex", 3, "xii");
+ SQAIMap.DefSQMethod(engine, &AIMap::DistanceManhattan, "DistanceManhattan", 3, "xii");
+ SQAIMap.DefSQMethod(engine, &AIMap::DistanceMax, "DistanceMax", 3, "xii");
+ SQAIMap.DefSQMethod(engine, &AIMap::DistanceSquare, "DistanceSquare", 3, "xii");
+ SQAIMap.DefSQMethod(engine, &AIMap::DistanceFromEdge, "DistanceFromEdge", 2, "xi");
+ SQAIMap.DefSQMethod(engine, &AIMap::DemolishTile, "DemolishTile", 2, "xi");
+
+ SQAIMap.PostRegister(engine);
+}
--- a/src/ai/api/ai_order.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_order.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -160,49 +160,4 @@
};
DECLARE_ENUM_AS_BIT_SET(AIOrder::AIOrderFlags);
-#ifdef DEFINE_SQUIRREL_CLASS
-namespace SQConvert {
- /* Allow enums to be used as Squirrel parameters */
- template <> AIOrder::AIOrderFlags GetParam(ForceType<AIOrder::AIOrderFlags>, HSQUIRRELVM vm, int index) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIOrder::AIOrderFlags)tmp; }
- 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 <> 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) {
- DefSQClass <AIOrder> SQAIOrder("AIOrder");
- SQAIOrder.PreRegister(engine);
- SQAIOrder.AddConstructor(engine);
-
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NONE, "AIOF_NONE");
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_TRANSFER, "AIOF_TRANSFER");
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_UNLOAD, "AIOF_UNLOAD");
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_FULL_LOAD, "AIOF_FULL_LOAD");
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_SERVICE_IF_NEEDED, "AIOF_SERVICE_IF_NEEDED");
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NON_STOP, "AIOF_NON_STOP");
- SQAIOrder.DefSQConst(engine, AIOrder::AIOF_INVALID, "AIOF_INVALID");
-
- SQAIOrder.DefSQStaticMethod(engine, &AIOrder::GetClassName, "GetClassName", 1, "x");
- SQAIOrder.DefSQStaticMethod(engine, &AIOrder::IsValidVehicleOrder, "IsValidVehicleOrder", 3, "xii");
- SQAIOrder.DefSQStaticMethod(engine, &AIOrder::AreOrderFlagsValid, "AreOrderFlagsValid", 3, "xii");
-
- SQAIOrder.DefSQMethod(engine, &AIOrder::GetNumberOfOrders, "GetNumberOfOrders", 2, "xi");
- SQAIOrder.DefSQMethod(engine, &AIOrder::GetOrderDestination, "GetOrderDestination", 3, "xii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::GetOrderFlags, "GetOrderFlags", 3, "xii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::AppendOrder, "AppendOrder", 4, "xiii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::InsertOrder, "InsertOrder", 5, "xiiii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::RemoveOrder, "RemoveOrder", 3, "xii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::ChangeOrder, "ChangeOrder", 4, "xiii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::CopyOrders, "CopyOrders", 3, "xii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::ShareOrders, "ShareOrders", 3, "xii");
- SQAIOrder.DefSQMethod(engine, &AIOrder::UnshareOrders, "UnshareOrders", 2, "xi");
-
- SQAIOrder.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_ORDER_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_order.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,44 @@
+#include "ai_order.hpp"
+
+namespace SQConvert {
+ /* Allow enums to be used as Squirrel parameters */
+ template <> AIOrder::AIOrderFlags GetParam(ForceType<AIOrder::AIOrderFlags>, HSQUIRRELVM vm, int index) { SQInteger tmp; sq_getinteger(vm, index, &tmp); return (AIOrder::AIOrderFlags)tmp; }
+ 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 <> 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) {
+ DefSQClass <AIOrder> SQAIOrder("AIOrder");
+ SQAIOrder.PreRegister(engine);
+ SQAIOrder.AddConstructor(engine);
+
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NONE, "AIOF_NONE");
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_TRANSFER, "AIOF_TRANSFER");
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_UNLOAD, "AIOF_UNLOAD");
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_FULL_LOAD, "AIOF_FULL_LOAD");
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_SERVICE_IF_NEEDED, "AIOF_SERVICE_IF_NEEDED");
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_NON_STOP, "AIOF_NON_STOP");
+ SQAIOrder.DefSQConst(engine, AIOrder::AIOF_INVALID, "AIOF_INVALID");
+
+ SQAIOrder.DefSQStaticMethod(engine, &AIOrder::GetClassName, "GetClassName", 1, "x");
+ SQAIOrder.DefSQStaticMethod(engine, &AIOrder::IsValidVehicleOrder, "IsValidVehicleOrder", 3, "xii");
+ SQAIOrder.DefSQStaticMethod(engine, &AIOrder::AreOrderFlagsValid, "AreOrderFlagsValid", 3, "xii");
+
+ SQAIOrder.DefSQMethod(engine, &AIOrder::GetNumberOfOrders, "GetNumberOfOrders", 2, "xi");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::GetOrderDestination, "GetOrderDestination", 3, "xii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::GetOrderFlags, "GetOrderFlags", 3, "xii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::AppendOrder, "AppendOrder", 4, "xiii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::InsertOrder, "InsertOrder", 5, "xiiii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::RemoveOrder, "RemoveOrder", 3, "xii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::ChangeOrder, "ChangeOrder", 4, "xiii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::CopyOrders, "CopyOrders", 3, "xii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::ShareOrders, "ShareOrders", 3, "xii");
+ SQAIOrder.DefSQMethod(engine, &AIOrder::UnshareOrders, "UnshareOrders", 2, "xi");
+
+ SQAIOrder.PostRegister(engine);
+}
--- a/src/ai/api/ai_road.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_road.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -174,39 +174,4 @@
bool RemoveRoadStation(TileIndex tile);
};
-#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 <> 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) {
- DefSQClass <AIRoad> SQAIRoad("AIRoad");
- SQAIRoad.PreRegister(engine);
- SQAIRoad.AddConstructor(engine);
-
- SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetClassName, "GetClassName", 1, "x");
-
- SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadTile, "IsRoadTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadDepotTile, "IsRoadDepotTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadStationTile, "IsRoadStationTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::IsDriveThroughRoadStationTile, "IsDriveThroughRoadStationTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::AreRoadTilesConnected, "AreRoadTilesConnected", 3, "xii");
- SQAIRoad.DefSQMethod(engine, &AIRoad::GetRoadDepotFrontTile, "GetRoadDepotFrontTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::GetRoadStationFrontTile, "GetRoadStationFrontTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::GetDriveThroughBackTile, "GetDriveThroughBackTile", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoad, "BuildRoad", 3, "xii");
- SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoadDepot, "BuildRoadDepot", 3, "xii");
- SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoadStation, "BuildRoadStation", 5, "xiibb");
- SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoad, "RemoveRoad", 3, "xii");
- SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoadDepot, "RemoveRoadDepot", 2, "xi");
- SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoadStation, "RemoveRoadStation", 2, "xi");
-
- SQAIRoad.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_ROAD_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_road.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,34 @@
+#include "ai_road.hpp"
+
+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 <> 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) {
+ DefSQClass <AIRoad> SQAIRoad("AIRoad");
+ SQAIRoad.PreRegister(engine);
+ SQAIRoad.AddConstructor(engine);
+
+ SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetClassName, "GetClassName", 1, "x");
+
+ SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadTile, "IsRoadTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadDepotTile, "IsRoadDepotTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadStationTile, "IsRoadStationTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::IsDriveThroughRoadStationTile, "IsDriveThroughRoadStationTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::AreRoadTilesConnected, "AreRoadTilesConnected", 3, "xii");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::GetRoadDepotFrontTile, "GetRoadDepotFrontTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::GetRoadStationFrontTile, "GetRoadStationFrontTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::GetDriveThroughBackTile, "GetDriveThroughBackTile", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoad, "BuildRoad", 3, "xii");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoadDepot, "BuildRoadDepot", 3, "xii");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoadStation, "BuildRoadStation", 5, "xiibb");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoad, "RemoveRoad", 3, "xii");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoadDepot, "RemoveRoadDepot", 2, "xi");
+ SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoadStation, "RemoveRoadStation", 2, "xi");
+
+ SQAIRoad.PostRegister(engine);
+}
--- a/src/ai/api/ai_settings.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_settings.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -30,26 +30,4 @@
void SetCommandDelay(uint ticks);
};
-#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 <> 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) {
- DefSQClass <AISettings> SQAISettings("AISettings");
- SQAISettings.PreRegister(engine);
- SQAISettings.AddConstructor(engine);
-
- SQAISettings.DefSQStaticMethod(engine, &AISettings::GetClassName, "GetClassName", 1, "x");
-
- SQAISettings.DefSQMethod(engine, &AISettings::SetCommandDelay, "SetCommandDelay", 2, "xi");
-
- SQAISettings.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_SETTINGS_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_settings.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,21 @@
+#include "ai_settings.hpp"
+
+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 <> 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) {
+ DefSQClass <AISettings> SQAISettings("AISettings");
+ SQAISettings.PreRegister(engine);
+ SQAISettings.AddConstructor(engine);
+
+ SQAISettings.DefSQStaticMethod(engine, &AISettings::GetClassName, "GetClassName", 1, "x");
+
+ SQAISettings.DefSQMethod(engine, &AISettings::SetCommandDelay, "SetCommandDelay", 2, "xi");
+
+ SQAISettings.PostRegister(engine);
+}
--- a/src/ai/api/ai_sign.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_sign.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -78,32 +78,4 @@
SignID BuildSign(TileIndex location, const char *text);
};
-#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 <> 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) {
- DefSQClass <AISign> SQAISign("AISign");
- SQAISign.PreRegister(engine);
- SQAISign.AddConstructor(engine);
-
- SQAISign.DefSQStaticMethod(engine, &AISign::GetClassName, "GetClassName", 1, "x");
- SQAISign.DefSQStaticMethod(engine, &AISign::IsValidSign, "IsValidSign", 2, "xi");
-
- SQAISign.DefSQMethod(engine, &AISign::GetMaxSignID, "GetMaxSignID", 1, "x");
- SQAISign.DefSQMethod(engine, &AISign::GetSignCount, "GetSignCount", 1, "x");
- SQAISign.DefSQMethod(engine, &AISign::GetText, "GetText", 2, "xi");
- SQAISign.DefSQMethod(engine, &AISign::GetLocation, "GetLocation", 2, "xi");
- SQAISign.DefSQMethod(engine, &AISign::RemoveSign, "RemoveSign", 2, "xi");
- SQAISign.DefSQMethod(engine, &AISign::BuildSign, "BuildSign", 3, "xis");
-
- SQAISign.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_SIGN_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_sign.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,27 @@
+#include "ai_sign.hpp"
+
+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 <> 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) {
+ DefSQClass <AISign> SQAISign("AISign");
+ SQAISign.PreRegister(engine);
+ SQAISign.AddConstructor(engine);
+
+ SQAISign.DefSQStaticMethod(engine, &AISign::GetClassName, "GetClassName", 1, "x");
+ SQAISign.DefSQStaticMethod(engine, &AISign::IsValidSign, "IsValidSign", 2, "xi");
+
+ SQAISign.DefSQMethod(engine, &AISign::GetMaxSignID, "GetMaxSignID", 1, "x");
+ SQAISign.DefSQMethod(engine, &AISign::GetSignCount, "GetSignCount", 1, "x");
+ SQAISign.DefSQMethod(engine, &AISign::GetText, "GetText", 2, "xi");
+ SQAISign.DefSQMethod(engine, &AISign::GetLocation, "GetLocation", 2, "xi");
+ SQAISign.DefSQMethod(engine, &AISign::RemoveSign, "RemoveSign", 2, "xi");
+ SQAISign.DefSQMethod(engine, &AISign::BuildSign, "BuildSign", 3, "xis");
+
+ SQAISign.PostRegister(engine);
+}
--- a/src/ai/api/ai_testmode.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_testmode.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -47,24 +47,4 @@
~AITestMode();
};
-#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 <> 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) {
- DefSQClass <AITestMode> SQAITestMode("AITestMode");
- SQAITestMode.PreRegister(engine);
- SQAITestMode.AddConstructor(engine);
-
- SQAITestMode.DefSQStaticMethod(engine, &AITestMode::GetClassName, "GetClassName", 1, "x");
-
- SQAITestMode.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TESTMODE_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_testmode.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,19 @@
+#include "ai_testmode.hpp"
+
+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 <> 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) {
+ DefSQClass <AITestMode> SQAITestMode("AITestMode");
+ SQAITestMode.PreRegister(engine);
+ SQAITestMode.AddConstructor(engine);
+
+ SQAITestMode.DefSQStaticMethod(engine, &AITestMode::GetClassName, "GetClassName", 1, "x");
+
+ SQAITestMode.PostRegister(engine);
+}
--- a/src/ai/api/ai_tilelist.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_tilelist.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -59,29 +59,4 @@
void RemoveTile(TileIndex tile);
};
-#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 <> 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) {
- DefSQClass <AITileList> SQAITileList("AITileList");
- SQAITileList.PreRegister(engine, "AIAbstractList");
- SQAITileList.AddConstructor(engine);
-
- SQAITileList.DefSQStaticMethod(engine, &AITileList::GetClassName, "GetClassName", 1, "x");
-
- SQAITileList.DefSQMethod(engine, &AITileList::AddRectangle, "AddRectangle", 3, "xii");
- SQAITileList.DefSQMethod(engine, &AITileList::AddTile, "AddTile", 2, "xi");
- SQAITileList.DefSQMethod(engine, &AITileList::RemoveRectangle, "RemoveRectangle", 3, "xii");
- SQAITileList.DefSQMethod(engine, &AITileList::RemoveTile, "RemoveTile", 2, "xi");
-
- SQAITileList.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TILELIST_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_tilelist.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,24 @@
+#include "ai_tilelist.hpp"
+
+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 <> 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) {
+ DefSQClass <AITileList> SQAITileList("AITileList");
+ SQAITileList.PreRegister(engine, "AIAbstractList");
+ SQAITileList.AddConstructor(engine);
+
+ SQAITileList.DefSQStaticMethod(engine, &AITileList::GetClassName, "GetClassName", 1, "x");
+
+ SQAITileList.DefSQMethod(engine, &AITileList::AddRectangle, "AddRectangle", 3, "xii");
+ SQAITileList.DefSQMethod(engine, &AITileList::AddTile, "AddTile", 2, "xi");
+ SQAITileList.DefSQMethod(engine, &AITileList::RemoveRectangle, "RemoveRectangle", 3, "xii");
+ SQAITileList.DefSQMethod(engine, &AITileList::RemoveTile, "RemoveTile", 2, "xi");
+
+ SQAITileList.PostRegister(engine);
+}
--- a/src/ai/api/ai_tilelist_valuator.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_tilelist_valuator.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -23,24 +23,4 @@
int32 Valuate(int32 tile) const;
};
-#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 <> 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) {
- DefSQClass <AITileListBuildable> SQAITileListBuildable("AITileListBuildable");
- SQAITileListBuildable.PreRegister(engine);
- SQAITileListBuildable.AddConstructor(engine);
-
- SQAITileListBuildable.DefSQStaticMethod(engine, &AITileListBuildable::GetClassName, "GetClassName", 1, "x");
-
- SQAITileListBuildable.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TILELIST_VALUATOR_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_tilelist_valuator.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,19 @@
+#include "ai_tilelist_valuator.hpp"
+
+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 <> 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) {
+ DefSQClass <AITileListBuildable> SQAITileListBuildable("AITileListBuildable");
+ SQAITileListBuildable.PreRegister(engine);
+ SQAITileListBuildable.AddConstructor(engine);
+
+ SQAITileListBuildable.DefSQStaticMethod(engine, &AITileListBuildable::GetClassName, "GetClassName", 1, "x");
+
+ SQAITileListBuildable.PostRegister(engine);
+}
--- a/src/ai/api/ai_town.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_town.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -67,31 +67,4 @@
static TileIndex GetLocation(TownID town_id);
};
-#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 <> 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) {
- DefSQClass <AITown> SQAITown("AITown");
- SQAITown.PreRegister(engine);
- SQAITown.AddConstructor(engine);
-
- SQAITown.DefSQStaticMethod(engine, &AITown::GetClassName, "GetClassName", 1, "x");
- SQAITown.DefSQStaticMethod(engine, &AITown::IsValidTown, "IsValidTown", 2, "xi");
- SQAITown.DefSQStaticMethod(engine, &AITown::GetName, "GetName", 2, "xi");
- SQAITown.DefSQStaticMethod(engine, &AITown::GetPopulation, "GetPopulation", 2, "xi");
- SQAITown.DefSQStaticMethod(engine, &AITown::GetLocation, "GetLocation", 2, "xi");
-
- SQAITown.DefSQMethod(engine, &AITown::GetMaxTownID, "GetMaxTownID", 1, "x");
- SQAITown.DefSQMethod(engine, &AITown::GetTownCount, "GetTownCount", 1, "x");
-
- SQAITown.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TOWN_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_town.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,26 @@
+#include "ai_town.hpp"
+
+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 <> 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) {
+ DefSQClass <AITown> SQAITown("AITown");
+ SQAITown.PreRegister(engine);
+ SQAITown.AddConstructor(engine);
+
+ SQAITown.DefSQStaticMethod(engine, &AITown::GetClassName, "GetClassName", 1, "x");
+ SQAITown.DefSQStaticMethod(engine, &AITown::IsValidTown, "IsValidTown", 2, "xi");
+ SQAITown.DefSQStaticMethod(engine, &AITown::GetName, "GetName", 2, "xi");
+ SQAITown.DefSQStaticMethod(engine, &AITown::GetPopulation, "GetPopulation", 2, "xi");
+ SQAITown.DefSQStaticMethod(engine, &AITown::GetLocation, "GetLocation", 2, "xi");
+
+ SQAITown.DefSQMethod(engine, &AITown::GetMaxTownID, "GetMaxTownID", 1, "x");
+ SQAITown.DefSQMethod(engine, &AITown::GetTownCount, "GetTownCount", 1, "x");
+
+ SQAITown.PostRegister(engine);
+}
--- a/src/ai/api/ai_townlist.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_townlist.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -23,24 +23,4 @@
AITownList();
};
-#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 <> 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) {
- DefSQClass <AITownList> SQAITownList("AITownList");
- SQAITownList.PreRegister(engine, "AIAbstractList");
- SQAITownList.AddConstructor(engine);
-
- SQAITownList.DefSQStaticMethod(engine, &AITownList::GetClassName, "GetClassName", 1, "x");
-
- SQAITownList.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TOWNLIST_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_townlist.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,19 @@
+#include "ai_townlist.hpp"
+
+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 <> 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) {
+ DefSQClass <AITownList> SQAITownList("AITownList");
+ SQAITownList.PreRegister(engine, "AIAbstractList");
+ SQAITownList.AddConstructor(engine);
+
+ SQAITownList.DefSQStaticMethod(engine, &AITownList::GetClassName, "GetClassName", 1, "x");
+
+ SQAITownList.PostRegister(engine);
+}
--- a/src/ai/api/ai_townlist_valuator.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_townlist_valuator.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -23,26 +23,6 @@
int32 Valuate(int32 town) const;
};
-#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 <> 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) {
- DefSQClass <AITownListGetPopulation> SQAITownListGetPopulation("AITownListGetPopulation");
- SQAITownListGetPopulation.PreRegister(engine);
- SQAITownListGetPopulation.AddConstructor(engine);
-
- SQAITownListGetPopulation.DefSQStaticMethod(engine, &AITownListGetPopulation::GetClassName, "GetClassName", 1, "x");
-
- SQAITownListGetPopulation.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
/**
* Get the location for entries in an AITownList instance.
* @note resulting items are of the type TileIndex
@@ -59,24 +39,4 @@
int32 Valuate(int32 town) const;
};
-#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 <> 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) {
- DefSQClass <AITownListGetLocation> SQAITownListGetLocation("AITownListGetLocation");
- SQAITownListGetLocation.PreRegister(engine);
- SQAITownListGetLocation.AddConstructor(engine);
-
- SQAITownListGetLocation.DefSQStaticMethod(engine, &AITownListGetLocation::GetClassName, "GetClassName", 1, "x");
-
- SQAITownListGetLocation.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TOWNLIST_VALUATOR_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_townlist_valuator.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,37 @@
+#include "ai_townlist_valuator.hpp"
+
+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 <> 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) {
+ DefSQClass <AITownListGetPopulation> SQAITownListGetPopulation("AITownListGetPopulation");
+ SQAITownListGetPopulation.PreRegister(engine);
+ SQAITownListGetPopulation.AddConstructor(engine);
+
+ SQAITownListGetPopulation.DefSQStaticMethod(engine, &AITownListGetPopulation::GetClassName, "GetClassName", 1, "x");
+
+ SQAITownListGetPopulation.PostRegister(engine);
+}
+
+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 <> 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) {
+ DefSQClass <AITownListGetLocation> SQAITownListGetLocation("AITownListGetLocation");
+ SQAITownListGetLocation.PreRegister(engine);
+ SQAITownListGetLocation.AddConstructor(engine);
+
+ SQAITownListGetLocation.DefSQStaticMethod(engine, &AITownListGetLocation::GetClassName, "GetClassName", 1, "x");
+
+ SQAITownListGetLocation.PostRegister(engine);
+}
--- a/src/ai/api/ai_transactionmode.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_transactionmode.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -106,30 +106,4 @@
void Append(AITransactionMode *transaction);
};
-#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 <> 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) {
- DefSQClass <AITransactionMode> SQAITransactionMode("AITransactionMode");
- SQAITransactionMode.PreRegister(engine);
- SQAITransactionMode.AddConstructor(engine);
-
- SQAITransactionMode.DefSQStaticMethod(engine, &AITransactionMode::GetClassName, "GetClassName", 1, "x");
-
- SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Execute, "Execute", 1, "x");
- SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Stop, "Stop", 1, "x");
- SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Rollback, "Rollback", 1, "x");
- SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::GetCosts, "GetCosts", 1, "x");
- SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Append, "Append", 2, "xx");
-
- SQAITransactionMode.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_TRANSACTIONMODE_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_transactionmode.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,25 @@
+#include "ai_transactionmode.hpp"
+
+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 <> 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) {
+ DefSQClass <AITransactionMode> SQAITransactionMode("AITransactionMode");
+ SQAITransactionMode.PreRegister(engine);
+ SQAITransactionMode.AddConstructor(engine);
+
+ SQAITransactionMode.DefSQStaticMethod(engine, &AITransactionMode::GetClassName, "GetClassName", 1, "x");
+
+ SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Execute, "Execute", 1, "x");
+ SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Stop, "Stop", 1, "x");
+ SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Rollback, "Rollback", 1, "x");
+ SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::GetCosts, "GetCosts", 1, "x");
+ SQAITransactionMode.DefSQMethod(engine, &AITransactionMode::Append, "Append", 2, "xx");
+
+ SQAITransactionMode.PostRegister(engine);
+}
--- a/src/ai/api/ai_vehicle.hpp Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/ai_vehicle.hpp Sat Apr 14 21:57:44 2007 +0000
@@ -123,35 +123,4 @@
bool SkipVehicleOrder(VehicleID vehicle_id);
};
-#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 <> 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) {
- DefSQClass <AIVehicle> SQAIVehicle("AIVehicle");
- SQAIVehicle.PreRegister(engine);
- SQAIVehicle.AddConstructor(engine);
-
- SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetClassName, "GetClassName", 1, "x");
- SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsValidEngine, "IsValidEngine", 2, "xi");
- SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsValidVehicle, "IsValidVehicle", 2, "xi");
-
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::FindBestRoadVehicle, "FindBestRoadVehicle", 3, "xii");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::BuildVehicle, "BuildVehicle", 3, "xii");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::CloneVehicle, "CloneVehicle", 4, "xiib");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::RefitVehicle, "RefitVehicle", 3, "xii");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::SellVehicle, "SellVehicle", 2, "xi");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::SendVehicleToDepot, "SendVehicleToDepot", 2, "xi");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::StartStopVehicle, "StartStopVehicle", 2, "xi");
- SQAIVehicle.DefSQMethod(engine, &AIVehicle::SkipVehicleOrder, "SkipVehicleOrder", 2, "xi");
-
- SQAIVehicle.PostRegister(engine);
-}
-#endif /* DEFINE_SQUIRREL_CLASS */
-
#endif /* AI_VEHICLE_HPP */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/ai/api/ai_vehicle.hpp.sq Sat Apr 14 21:57:44 2007 +0000
@@ -0,0 +1,30 @@
+#include "ai_vehicle.hpp"
+
+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 <> 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) {
+ DefSQClass <AIVehicle> SQAIVehicle("AIVehicle");
+ SQAIVehicle.PreRegister(engine);
+ SQAIVehicle.AddConstructor(engine);
+
+ SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::GetClassName, "GetClassName", 1, "x");
+ SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsValidEngine, "IsValidEngine", 2, "xi");
+ SQAIVehicle.DefSQStaticMethod(engine, &AIVehicle::IsValidVehicle, "IsValidVehicle", 2, "xi");
+
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::FindBestRoadVehicle, "FindBestRoadVehicle", 3, "xii");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::BuildVehicle, "BuildVehicle", 3, "xii");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::CloneVehicle, "CloneVehicle", 4, "xiib");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::RefitVehicle, "RefitVehicle", 3, "xii");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::SellVehicle, "SellVehicle", 2, "xi");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::SendVehicleToDepot, "SendVehicleToDepot", 2, "xi");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::StartStopVehicle, "StartStopVehicle", 2, "xi");
+ SQAIVehicle.DefSQMethod(engine, &AIVehicle::SkipVehicleOrder, "SkipVehicleOrder", 2, "xi");
+
+ SQAIVehicle.PostRegister(engine);
+}
--- a/src/ai/api/squirrel_export.awk Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/squirrel_export.awk Sat Apr 14 21:57:44 2007 +0000
@@ -36,13 +36,15 @@
cls_level = 0
}
+/@file/ {
+ print "#include \"" $3 "\""
+}
+
# Remove the old squirrel stuff
/#ifdef DEFINE_SQUIRREL_CLASS/ { squirrel_stuff = "true"; next; }
/^#endif \/\* DEFINE_SQUIRREL_CLASS \*\// { if (squirrel_stuff == "true") { squirrel_stuff = "false"; next; } }
{ if (squirrel_stuff == "true") next; }
-{ print $0; }
-
# Ignore forward declarations of classes
/^( *)class(.*);/ { next; }
# We only want to have public functions exported for now
@@ -112,9 +114,10 @@
if (start_squirrel_define_on_next_line == "false") next
spaces = " ";
public = "false"
- print "#ifdef DEFINE_SQUIRREL_CLASS"
namespace_opened = "false"
+ print ""
+
# First check whether we have enums to print
if (enum_size != 0) {
if (namespace_opened == "false") {
@@ -203,8 +206,6 @@
print "}"
}
- print "#endif /* DEFINE_SQUIRREL_CLASS */"
-
enum_size = 0
enum_value_size = 0
struct_size = 0
--- a/src/ai/api/squirrel_export.sh Sat Apr 14 21:01:44 2007 +0000
+++ b/src/ai/api/squirrel_export.sh Sat Apr 14 21:57:44 2007 +0000
@@ -9,18 +9,24 @@
"ai_controller.hpp" | "ai_object.hpp") continue;
esac
awk -f squirrel_export.awk ${f} > ${f}.tmp
- if [ -n "`diff ${f} ${f}.tmp`" ]; then
- mv ${f}.tmp ${f}
+ if [ -n "`diff ${f}.tmp ${f}.sq 2> /dev/null || echo boo`" ]; then
+ mv ${f}.tmp ${f}.sq
echo "Updated: ${f}"
+ svn add ${f}.sq > /dev/null 2>&1
+ svn propset svn:eol-style native ${f}.sq > /dev/null 2>&1
+ svn propset svn:keywords Id ${f}.sq > /dev/null 2>&1
else
rm -f ${f}.tmp
fi
done
else
awk -f squirrel_export.awk $1 > $1.tmp
- if [ -n "`diff $1 $1.tmp`" ]; then
- mv $1.tmp $1
+ if [ -n "`diff $1.sq $1.tmp`" ]; then
+ mv $1.tmp $1.sq
echo "Updated: $1"
+ svn add $1.sq > /dev/null 2>&1
+ svn propset svn:eol-style native $1.sq > /dev/null 2>&1
+ svn propset svn:keywords Id $1.sq > /dev/null 2>&1
else
rm -f $1.tmp
fi
@@ -37,7 +43,7 @@
/#define DEFINE_SQUIRREL_CLASS/ {
squirrel_stuff = \"true\";
print \"#define DEFINE_SQUIRREL_CLASS\"
- split(\"`grep '^void SQAI.*Register(Squirrel \*engine) {$' *.hpp | sed 's/:.*$//' | sort | uniq | tr -d '\r' | tr '\n' ' '`\", files, \" \")
+ split(\"`grep '^void SQAI.*Register(Squirrel \*engine) {$' *.hpp.sq | sed 's/:.*$//' | sort | uniq | tr -d '\r' | tr '\n' ' '`\", files, \" \")
for (i = 1; files[i] != \"\"; i++) {
print \"#include \\\"api/\" files[i] \"\\\"\"
@@ -55,7 +61,7 @@
squirrel_stuff = \"true\";
print \" /* Register all classes */\"
print \" squirrel_register_std(this->engine);\"
- split(\"`grep '^void SQAI.*Register(Squirrel \*engine) {$' *.hpp | sed 's/^.*void //;s/Squirrel \*/this->/;s/ {/;/' | sort | tr -d '\r' | tr '\n' ' '`\", regs, \" \")
+ split(\"`grep '^void SQAI.*Register(Squirrel \*engine) {$' *.hpp.sq | sed 's/^.*void //;s/Squirrel \*/this->/;s/ {/;/' | sort | tr -d '\r' | tr '\n' ' '`\", regs, \" \")
for (i = 1; regs[i] != \"\"; i++) {
print \" \" regs[i]