Fixed a nasty order of destruction bug, where the memory pool for ScriptInts was destroyed before the PackageManager

git-svn-id: svn://svn.code.sf.net/p/magicseteditor/code/trunk@20 0fc631ac-6414-0410-93d0-97cfa31319b6
2026-06-10 13:06:59 -04:00 · 2006-10-12 17:08:02 +00:00
parent 6fe45ca28b
commit b13d0b81ae
13 changed files with 257 additions and 41 deletions
@@ -0,0 +1,57 @@
+//+----------------------------------------------------------------------------+
+//| Description:  Magic Set Editor - Program to make Magic (tm) cards          |
+//| Copyright:    (C) 2001 - 2006 Twan van Laarhoven                           |
+//| License:      GNU General Public License 2 or later (see file COPYING)     |
+//+----------------------------------------------------------------------------+
+
+// ----------------------------------------------------------------------------- : Includes
+
+#include <script/scriptable.hpp>
+#include <script/context.hpp>
+#include <script/parser.hpp>
+#include <script/script.hpp>
+#include <script/value.hpp>
+
+// ----------------------------------------------------------------------------- : Store
+
+void store(const ScriptValueP& val, String& var)              { var = static_cast<String>(*val); }
+void store(const ScriptValueP& val, int&    var)              { var = *val; }
+void store(const ScriptValueP& val, double& var)              { var = *val; }
+void store(const ScriptValueP& val, bool&   var)              { var = static_cast<int>(*val); }
+void store(const ScriptValueP& val, Defaultable<String>& var) { var.assign(*val); }
+
+// ----------------------------------------------------------------------------- : OptionalScript
+
+OptionalScript::~OptionalScript() {}
+
+ScriptValueP OptionalScript::invoke(Context& ctx) {
+	if (script) {
+		return ctx.eval(*script);
+	} else {
+		return script_nil;
+	}
+}
+
+// custom reflection, different for each type
+
+template <> void Reader::handle(OptionalScript& os) {
+	handle(os.unparsed);
+	// read the script
+	os.script = parse(os.unparsed);
+}
+
+template <> void Writer::handle(const OptionalScript& os) {
+	handle(os.unparsed);
+}
+
+template <> void GetMember::handle(const OptionalScript& os) {
+	// no members
+}
+template <> void GetMember::store(const OptionalScript& os) {
+	// reflect as the script itself
+	if (os.script) {
+		store(os.script);
+	} else {
+		store(script_nil);
+	}
+}
@@ -0,0 +1,89 @@
+//+----------------------------------------------------------------------------+
+//| Description:  Magic Set Editor - Program to make Magic (tm) cards          |
+//| Copyright:    (C) 2001 - 2006 Twan van Laarhoven                           |
+//| License:      GNU General Public License 2 or later (see file COPYING)     |
+//+----------------------------------------------------------------------------+
+
+#ifndef HEADER_SCRIPT_SCRIPTABLE
+#define HEADER_SCRIPT_SCRIPTABLE
+
+// ----------------------------------------------------------------------------- : Includes
+
+#include <util/prec.hpp>
+#include <util/reflect.hpp>
+#include <util/defaultable.hpp>
+
+DECLARE_INTRUSIVE_POINTER_TYPE(Script);
+class Context;
+
+// ----------------------------------------------------------------------------- : Store
+
+/// Store a ScriptValue in a variable
+void store(const ScriptValueP& val, String& var);
+void store(const ScriptValueP& val, int&    var);
+void store(const ScriptValueP& val, double& var);
+void store(const ScriptValueP& val, bool&   var);
+void store(const ScriptValueP& val, Defaultable<String>& var);
+
+// ----------------------------------------------------------------------------- : OptionalScript
+
+/// An optional script, 
+class OptionalScript {
+  public:
+	~OptionalScript();
+	/// Is the script set?
+	inline operator bool() { return !!script; }
+	
+	/// Invoke the script, return the result, or script_nil if there is no script
+	ScriptValueP invoke(Context& ctx);
+	
+	/// Invoke the script on a value
+	/** Assigns the result to value if it has changed.
+	 *  Returns true if the value has changed.
+	 */
+	template <typename T>
+	bool invokeOn(Context& ctx, T& value) {
+		if (script) {
+			T new_value;
+			store(new_value, script->invoke(ctx));
+			if (value != new_value) {
+				value = new_value;
+				return true;
+			}
+		}
+		return false;
+	}
+	
+  private:
+	ScriptP script;		///< The script, may be null if there is no script
+	String unparsed;	///< Unparsed script, for writing back to a file
+	DECLARE_REFLECTION();
+};
+
+// ----------------------------------------------------------------------------- : Scriptable
+
+/// A script that defines a calculation to find a value
+/** NOTE: reading MUST happen inside a block */
+template <typename T>
+class Scriptable {
+  public:
+	Scriptable()               : value()      {}
+	Scriptable(const T& value) : value(value) {}
+	
+	inline operator const T& () const { return value; }
+	inline bool isScripted() const { return script; }
+	
+	// Updates the value by executing the script, returns true if the value has changed
+	inline bool update(Context& ctx) {
+		return script.invokeOn(ctx, value);
+	}
+	
+  private:
+	OptionalScript script;	///< The optional script
+	T value;				///< The scripted value
+	
+	DECLARE_REFLECTION();
+};
+
+// ----------------------------------------------------------------------------- : EOF
+#endif
@@ -56,6 +56,8 @@ ScriptValueP rangeIterator(int start, int end) {

 // ----------------------------------------------------------------------------- : Integers

+#define USE_POOL_ALLOCATOR
+
 // Integer values
 class ScriptInt : public ScriptValue {
  public:
@@ -66,23 +68,59 @@ class ScriptInt : public ScriptValue {
 	virtual operator double() const { return value; }
 	virtual operator int()    const { return value; }
  protected:
+#ifdef USE_POOL_ALLOCATOR
 	virtual void destroy() {
 		boost::singleton_pool<ScriptValue, sizeof(ScriptInt)>::free(this);
 	}
+#endif
  private:
 	int value;
 };

+#if defined(USE_POOL_ALLOCATOR) && !defined(USE_INTRUSIVE_PTR)
+	// deallocation function for pool allocated integers
+	void destroy_value(ScriptInt* v) {
+		boost::singleton_pool<ScriptValue, sizeof(ScriptInt)>::free(v);
+	}
+#endif
+
 ScriptValueP toScript(int v) {
-//	return new_intrusive1<ScriptInt>(v);
-	return ScriptValueP(
-			new(boost::singleton_pool<ScriptValue, sizeof(ScriptInt)>::malloc())
-				ScriptInt(v));
+#ifdef USE_POOL_ALLOCATOR
+	#ifdef USE_INTRUSIVE_PTR
+		return ScriptValueP(
+				new(boost::singleton_pool<ScriptValue, sizeof(ScriptInt)>::malloc())
+					ScriptInt(v));
+	#else
+		return ScriptValueP(
+				new(boost::singleton_pool<ScriptValue, sizeof(ScriptInt)>::malloc())
+					ScriptInt(v),
+				destroy_value); // deallocation function
+	#endif
+#else
+	return new_intrusive1<ScriptInt>(v);
+#endif
 }

+// ----------------------------------------------------------------------------- : Booleans
+
+// Boolean values
+class ScriptBool : public ScriptValue {
+  public:
+	ScriptBool(bool v) : value(v) {}
+	virtual ScriptType type() const { return SCRIPT_INT; }
+	virtual String typeName() const { return _("boolean"); }
+	virtual operator String() const { return value ? _("true") : _("false"); }
+	virtual operator int()    const { return value; }
+  private:
+	bool value;
+};
+
 // use integers to represent true/false
-ScriptValueP script_true  = toScript((int)true);
-ScriptValueP script_false = toScript((int)false);
+/* NOTE: previous versions used ScriptInts as booleans, this gives problems
+ * when we use a pool allocator for them, because the pool is destroyed before these globals.
+ */
+ScriptValueP script_true (new ScriptBool(true));
+ScriptValueP script_false(new ScriptBool(false));


 // ----------------------------------------------------------------------------- : Doubles
@@ -11,7 +11,6 @@

 #include <util/prec.hpp>
 #include <util/error.hpp>
-#include <boost/intrusive_ptr.hpp>
 class Context;
 class Dependency;

@@ -46,7 +45,11 @@ enum ScriptType
 /// Actual values are derived types
 class ScriptValue {
  public:
-	inline ScriptValue() : refCount(0) {}
+	inline ScriptValue()
+		#ifdef USE_INTRUSIVE_PTR
+			 : refCount(0)
+		#endif
+	{}
 	virtual ~ScriptValue() {}
 	
 	/// Information on the type of this value
@@ -85,22 +88,26 @@ class ScriptValue {
 	virtual void destroy() {
 		delete this;
 	}
+#ifdef USE_INTRUSIVE_PTR
  private:
 	volatile LONG refCount;
 	friend void intrusive_ptr_add_ref(ScriptValue*);
 	friend void intrusive_ptr_release(ScriptValue*);
+#endif
 };

-inline void intrusive_ptr_add_ref(ScriptValue* p) {
-	//p->refCount += 1;
-	InterlockedIncrement(&p->refCount);
-}
-inline void intrusive_ptr_release(ScriptValue* p) {
-	if (InterlockedDecrement(&p->refCount) == 0) {
-	//if (--p->refCount == 0) {
-		p->destroy();
+#ifdef USE_INTRUSIVE_PTR
+	inline void intrusive_ptr_add_ref(ScriptValue* p) {
+		//p->refCount += 1;
+		InterlockedIncrement(&p->refCount);
 	}
-}
+	inline void intrusive_ptr_release(ScriptValue* p) {
+		if (InterlockedDecrement(&p->refCount) == 0) {
+		//if (--p->refCount == 0) {
+			p->destroy();
+		}
+	}
+#endif

 extern ScriptValueP script_nil;   ///< The preallocated nil value
 extern ScriptValueP script_true;  ///< The preallocated true value