Merged in cwalther/cwe/notify_int (mainly by boq) (https://foundry.openuru.org/fisheye/cru/CWE-12)

Allow plNotify variable events to carry integers in addition to floats

This fixes crashes when trying to upload a KI note with an odd vault node id > 2^24 to an imager, and allows for future cleanup of other plNotifyMsg uses.

To be accompanied by moulscript 886c4.

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp

@@ -1363,12 +1363,19 @@ hsBool plPythonFileMod::MsgReceive(plMessage* msg)
 							// depending on the data type create the data
 							switch ( eventData->fDataType )
 							{
-								case proEventData::kNumber:
-									PyList_SetItem(event, 3, PyFloat_FromDouble(eventData->fNumber));
+								case proEventData::kFloat:
+									PyList_SetItem(event, 3, PyFloat_FromDouble(eventData->fNumber.f));
 									break;
 								case proEventData::kKey:
 									PyList_SetItem(event, 3, pyKey::New(eventData->fKey));
 									break;
+								case proEventData::kInt:
+									PyList_SetItem(event, 3, PyInt_FromLong(eventData->fNumber.i));
+									break;
+								default:
+									Py_XINCREF(Py_None);
+									PyList_SetItem(event, 3, Py_None);
+									break;
 							}
 							// add this event record to the main event list (lists within a list)
 							PyList_Append(levents, event);

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pyNotify.cpp

@@ -151,6 +151,16 @@ void pyNotify::AddVarNumber(const char* name, hsScalar number)
 	fBuildMsg.AddVariableEvent(name,number);
 }
 
+void pyNotify::AddVarNumber(const char* name, Int32 number)
+{
+	fBuildMsg.AddVariableEvent(name,number);
+}
+
+void pyNotify::AddVarNull(const char* name)
+{
+	fBuildMsg.AddVariableEvent(name);
+}
+
 void pyNotify::AddVarKey(const char* name, pyKey* key)
 {
 	fBuildMsg.AddVariableEvent(name, key ? key->getKey() : plKey() );

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pyNotify.h

@@ -100,6 +100,8 @@ public:
 	virtual void AddPickEvent(hsBool enabled, pyKey* other, pyKey* self, pyPoint3 hitPoint);
 	virtual void AddControlKeyEvent( Int32 key, hsBool down );
 	virtual void AddVarNumber(const char* name, hsScalar number);
+	virtual void AddVarNumber(const char* name, Int32 number);
+	virtual void AddVarNull(const char* name);
 	virtual void AddVarKey(const char* name, pyKey* key);
 	virtual void AddFacingEvent( hsBool enabled, pyKey* other, pyKey* self, hsScalar dot);
 	virtual void AddContainerEvent( hsBool entering, pyKey* container, pyKey* contained);

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pyNotifyGlue.cpp

@@ -194,18 +194,86 @@ PYTHON_METHOD_DEFINITION(ptNotify, addControlKeyEvent, args)
 }
 
 PYTHON_METHOD_DEFINITION(ptNotify, addVarNumber, args)
+{
+	char* name;
+	PyObject* number = NULL;
+	if (!PyArg_ParseTuple(args, "s|O", &name, &number))
+	{
+		PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and optional number");
+		PYTHON_RETURN_ERROR;
+	}
+
+	if (number == NULL || number == Py_None)
+		self->fThis->AddVarNull(name);
+	else if (PyInt_Check(number))
+		self->fThis->AddVarNumber(name, PyInt_AsLong(number));
+	else if (PyLong_Check(number))
+	{
+		// try as int first
+		Int32 i = (Int32)PyLong_AsLong(number);
+		if (!PyErr_Occurred())
+		{
+			self->fThis->AddVarNumber(name, i);
+		}
+		else
+		{
+			// OverflowError, try float
+			PyErr_Clear();
+			self->fThis->AddVarNumber(name, (float)PyLong_AsDouble(number));
+		}
+	}
+	else if (PyNumber_Check(number)) 
+	{
+		PyObject* f = PyNumber_Float(number);
+		self->fThis->AddVarNumber(name, (float)PyFloat_AsDouble(f));
+		Py_DECREF(f);
+	} 
+	else
+	{
+		PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and optional number");
+		PYTHON_RETURN_ERROR;
+	}
+	PYTHON_RETURN_NONE;
+}
+
+PYTHON_METHOD_DEFINITION(ptNotify, addVarFloat, args)
 {
 	char* name;
 	float number;
 	if (!PyArg_ParseTuple(args, "sf", &name, &number))
 	{
-		PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and a float");
+		PyErr_SetString(PyExc_TypeError, "addVarFloat expects a string and a float");
 		PYTHON_RETURN_ERROR;
 	}
 	self->fThis->AddVarNumber(name, number);
 	PYTHON_RETURN_NONE;
 }
 
+PYTHON_METHOD_DEFINITION(ptNotify, addVarInt, args)
+{
+	char* name;
+	Int32 number;
+	if (!PyArg_ParseTuple(args, "sl", &name, &number))
+	{
+		PyErr_SetString(PyExc_TypeError, "addVarInt expects a string and a integer");
+		PYTHON_RETURN_ERROR;
+	}
+	self->fThis->AddVarNumber(name, number);
+	PYTHON_RETURN_NONE;
+}
+
+PYTHON_METHOD_DEFINITION(ptNotify, addVarNull, args)
+{
+	char* name;
+	if (!PyArg_ParseTuple(args, "s", &name))
+	{
+		PyErr_SetString(PyExc_TypeError, "addVarNull expects a string");
+		PYTHON_RETURN_ERROR;
+	}
+	self->fThis->AddVarNull(name);
+	PYTHON_RETURN_NONE;
+}
+
 PYTHON_METHOD_DEFINITION(ptNotify, addVarKey, args)
 {
 	char* name;
@@ -337,6 +405,13 @@ PYTHON_START_METHODS_TABLE(ptNotify)
 	PYTHON_METHOD(ptNotify, addPickEvent, "Params: enabledFlag,pickerKey,pickeeKey,hitPoint\nAdd a pick event record to the Notify message"),
 	PYTHON_METHOD(ptNotify, addControlKeyEvent, "Params: keynumber,downFlag\nAdd a keyboard event record to the Notify message"),
 	PYTHON_METHOD(ptNotify, addVarNumber, "Params: name,number\nAdd a number variable event record to the Notify message\n"
+				"Method will try to pick appropriate variable type\n"
+				"This event record is used to pass a number variable to another python program"),
+	PYTHON_METHOD(ptNotify, addVarFloat, "Params: name,number\nAdd a float variable event record to the Notify message\n"
+				"This event record is used to pass a number variable to another python program"),
+	PYTHON_METHOD(ptNotify, addVarInt, "Params: name,number\nAdd a int variable event record to the Notify message\n"
+				"This event record is used to pass a number variable to another python program"),
+	PYTHON_METHOD(ptNotify, addVarNull, "Params: name,number\nAdd a null (no data) variable event record to the Notify message\n"
 				"This event record is used to pass a number variable to another python program"),
 	PYTHON_METHOD(ptNotify, addVarKey, "Params: name,key\nAdd a ptKey variable event record to the Notify message\n"
 				"This event record is used to pass a ptKey variable to another python program"),
@@ -402,8 +477,10 @@ void pyNotify::AddPlasmaConstantsClasses(PyObject *m)
 	PYTHON_ENUM_END(m, PtEventType);
 
 	PYTHON_ENUM_START(PtNotifyDataType);
-	PYTHON_ENUM_ELEMENT(PtNotifyDataType, kNumber,	proEventData::kNumber);
-	PYTHON_ENUM_ELEMENT(PtNotifyDataType, kKey,		proEventData::kKey);
+	PYTHON_ENUM_ELEMENT(PtNotifyDataType, kFloat,  proEventData::kFloat);
+	PYTHON_ENUM_ELEMENT(PtNotifyDataType, kInt,  proEventData::kInt);
+	PYTHON_ENUM_ELEMENT(PtNotifyDataType, kNull,  proEventData::kNull);
+	PYTHON_ENUM_ELEMENT(PtNotifyDataType, kKey,     proEventData::kKey);
 	PYTHON_ENUM_END(m, PtNotifyDataType);
 
 	PYTHON_ENUM_START(PtMultiStageEventType);

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.cpp

@@ -173,8 +173,14 @@ void plNotifyMsg::AddEvent( proEventData* ed )
 				proVariableEventData *evt = (proVariableEventData *)ed;
 				switch (evt->fDataType)
 				{
-					case proEventData::kNumber:
-						AddVariableEvent(evt->fName, evt->fNumber);
+					case proEventData::kFloat:
+						AddVariableEvent(evt->fName, evt->fNumber.f);
+						break;
+					case proEventData::kInt:
+						AddVariableEvent(evt->fName, evt->fNumber.i);
+						break;
+					case proEventData::kNull:
+						AddVariableEvent(evt->fName);
 						break;
 					case proEventData::kKey:
 						AddVariableEvent(evt->fName, evt->fKey);
@@ -587,10 +593,43 @@ void plNotifyMsg::AddVariableEvent( const char* name, hsScalar number )
 	// create the control key event record
 	proVariableEventData* pED = TRACKED_NEW proVariableEventData;
 	pED->fName = hsStrcpy(nil,name);
-//	pED->fName = (char*)name;
-	pED->fDataType = proEventData::kNumber;
-	pED->fNumber = number;
-	fEvents.Append(pED);	// then add it to the list of event records
+	pED->fDataType = proEventData::kFloat;
+	pED->fNumber.f = number;
+	fEvents.Append(pED);    // then add it to the list of event records
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  Function   : AddVariableEvent
+//  PARAMETERS : name    - name of the variable
+//             : number  - the value of the variable as a number
+//
+//  PURPOSE    : Add a variable event record to this notify message
+//
+void plNotifyMsg::AddVariableEvent( const char* name, Int32 number )
+{
+	// create the control key event record
+	proVariableEventData* pED = TRACKED_NEW proVariableEventData;
+	pED->fName = hsStrcpy(nil,name);
+	pED->fDataType = proEventData::kInt;
+	pED->fNumber.i = number;
+	fEvents.Append(pED);    // then add it to the list of event records
+}
+
+/////////////////////////////////////////////////////////////////////////////
+//
+//  Function   : AddVariableEvent
+//  PARAMETERS : name    - name of the variable
+//
+//  PURPOSE    : Add a variable event record to this notify message
+//
+void plNotifyMsg::AddVariableEvent( const char* name)
+{
+    // create the control key event record
+    proVariableEventData* pED = TRACKED_NEW proVariableEventData;
+    pED->fName = hsStrcpy(nil,name);
+    pED->fDataType = proEventData::kNull;
+    fEvents.Append(pED);    // then add it to the list of event records
 }
 
 
@@ -1284,11 +1323,39 @@ void proVariableEventData::IDestruct()
 	fName = nil;
 }
 
+void proVariableEventData::IReadNumber(hsStream * stream) {
+	switch (fDataType) {
+	case kFloat:
+		fNumber.f = stream->ReadSwapScalar();
+		break;
+	case kInt:
+		fNumber.i = stream->ReadSwap32();
+		break;
+	default: 
+		stream->ReadSwap32(); //ignore
+		break;
+	}
+}
+
+void proVariableEventData::IWriteNumber(hsStream * stream) {
+	   switch (fDataType) {
+	case kFloat:
+		stream->WriteSwapScalar(fNumber.f);
+		break;
+	case kInt:
+		stream->WriteSwap32(fNumber.i);
+		break;
+	default: 
+		stream->WriteSwap32(0);
+		break;
+	}
+}
+
 void proVariableEventData::IRead(hsStream* stream, hsResMgr* mgr)
 {
 	fName = stream->ReadSafeString();
 	fDataType = stream->ReadSwap32();
-	fNumber = stream->ReadSwapScalar();
+	IReadNumber(stream);
 	fKey = mgr->ReadKey(stream);
 }
 
@@ -1296,7 +1363,7 @@ void proVariableEventData::IWrite(hsStream* stream, hsResMgr* mgr)
 {
 	stream->WriteSafeString(fName);
 	stream->WriteSwap32(fDataType);
-	stream->WriteSwapScalar(fNumber);
+	IWriteNumber(stream);
 	mgr->WriteKey(stream, fKey);
 }
 
@@ -1318,7 +1385,7 @@ void proVariableEventData::IReadVersion(hsStream* s, hsResMgr* mgr)
 	if (contentFlags.IsBitSet(kProVariableDataType))
 		fDataType = s->ReadSwap32();
 	if (contentFlags.IsBitSet(kProVariableNumber))
-		fNumber = s->ReadSwapScalar();
+		IReadNumber(s);
 	if (contentFlags.IsBitSet(kProVariableKey))
 		fKey = mgr->ReadKey(s);
 }
@@ -1337,7 +1404,7 @@ void proVariableEventData::IWriteVersion(hsStream* s, hsResMgr* mgr)
 	// kProVariableDataType
 	s->WriteSwap32(fDataType);
 	// kProVariableNumber
-	s->WriteSwapScalar(fNumber);
+	IWriteNumber(s);
 	// kProVariableKey
 	mgr->WriteKey(s, fKey);
 }

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.h

@@ -87,8 +87,10 @@ public:
 
 	enum dataType
 	{
-		kNumber=1,
+		kFloat=1,
 		kKey,
+		kInt,
+		kNull,
 		kNotta
 	};
 
@@ -181,7 +183,10 @@ proEventType(Variable)
 	Int32	fDataType;		// type of data
 
 	// Can't be a union, sadly, but it isn't that much of a waste of space...
-	hsScalar	fNumber;	// if its a number
+	union {
+		hsScalar f;
+		Int32 i;
+	} fNumber; // if its a number
 	plKey		fKey;		// if its a plKey (pointer to something)
 
 
@@ -193,6 +198,9 @@ protected:
 
 	virtual void IReadVersion(hsStream* s, hsResMgr* mgr);
 	virtual void IWriteVersion(hsStream* s, hsResMgr* mgr);
+
+	virtual void IReadNumber(hsStream * stream);
+	virtual void IWriteNumber(hsStream * stream);
 };
 
 proEventType(Facing)
@@ -368,6 +376,8 @@ public:
 	void AddPickEvent( const plKey &other, const plKey& self, hsBool enabled, hsPoint3 hitPoint );
 	void AddControlKeyEvent( Int32 key, hsBool down );
 	void AddVariableEvent( const char* name, hsScalar number );
+	void AddVariableEvent( const char* name, Int32 number );
+	void AddVariableEvent( const char* name );
 	void AddVariableEvent( const char *name, const plKey &key);
 	void AddFacingEvent( const plKey &other, const plKey &self, hsScalar dot, hsBool enabled);
 	void AddContainerEvent( const plKey &container, const plKey &contained, hsBool entering);