more changes.

Engine/source/console/consoleInternal.h

@@ -280,9 +280,18 @@ public:
 
    struct Entry
    {
+      friend class Dictionary;
+
+      enum
+      {
+         TypeInternalInt = -3,
+         TypeInternalFloat = -2,
+         TypeInternalString = -1,
+      };
+
       StringTableEntry name;
-      ConsoleValue value;
       Entry *nextEntry;
+      S32 type;
 
       typedef Signal<void()> NotifySignal;
 
@@ -296,6 +305,41 @@ public:
       /// Whether this is a constant that cannot be assigned to.
       bool mIsConstant;
 
+   protected:
+
+      // NOTE: This is protected to ensure no one outside
+      // of this structure is messing with it.
+
+#pragma warning( push )
+#pragma warning( disable : 4201 ) // warning C4201: nonstandard extension used : nameless struct/union
+
+      // An variable is either a real dynamic type or
+      // its one exposed from C++ using a data pointer.
+      //
+      // We use this nameless union and struct setup
+      // to optimize the memory usage.
+      union
+      {
+         struct
+         {
+            char* sval;
+            U32 ival;  // doubles as strlen when type is TypeInternalString
+            F32 fval;
+            U32 bufferLen;
+         };
+
+         struct
+         {
+            /// The real data pointer.
+            void* dataPtr;
+
+            /// The enum lookup table for enumerated types.
+            const EnumTable* enumTable;
+         };
+      };
+
+#pragma warning( pop ) // C4201
+
    public:
 
       Entry() {
@@ -312,26 +356,34 @@ public:
 
       Entry *mNext;
 
-      void reset() {
-         name = NULL;
-         value.reset();
-         if (notify)
-            delete notify;
-      }
+      void reset();
 
       inline U32 getIntValue()
       {
-         return value.getInt();
+         if (type <= TypeInternalString)
+            return ival;
+         else
+            return dAtoi(Con::getData(type, dataPtr, 0, enumTable));
       }
 
       inline F32 getFloatValue()
       {
-         return value.getFloat();
+         if (type <= TypeInternalString)
+            return fval;
+         else
+            return dAtof(Con::getData(type, dataPtr, 0, enumTable));
       }
 
       inline const char *getStringValue()
       {
-         return value.getString();
+         if (type == TypeInternalString)
+            return sval;
+         if (type == TypeInternalFloat)
+            return Con::getData(TypeF32, &fval, 0);
+         else if (type == TypeInternalInt)
+            return Con::getData(TypeS32, &ival, 0);
+         else
+            return Con::getData(type, dataPtr, 0, enumTable);
       }
 
       void setIntValue(U32 val)
@@ -342,7 +394,22 @@ public:
             return;
          }
 
-         value.setInt(val);
+         if (type <= TypeInternalString)
+         {
+            fval = (F32)val;
+            ival = val;
+            if (sval != typeValueEmpty)
+            {
+               dFree(sval);
+               sval = typeValueEmpty;
+            }
+            type = TypeInternalInt;
+         }
+         else
+         {
+            const char* dptr = Con::getData(TypeS32, &val, 0);
+            Con::setData(type, dataPtr, 0, 1, &dptr, enumTable);
+         }
 
          // Fire off the notification if we have one.
          if (notify)
@@ -357,27 +424,29 @@ public:
             return;
          }
 
-         value.setFloat(val);
-
-         // Fire off the notification if we have one.
-         if (notify)
-            notify->trigger();
-      }
-
-      void setStringValue(const char *newValue)
-      {
-         if (mIsConstant)
+         if (type <= TypeInternalString)
          {
-            Con::errorf("Cannot assign value to constant '%s'.", name);
-            return;
+            fval = val;
+            ival = static_cast<U32>(val);
+            if (sval != typeValueEmpty)
+            {
+               dFree(sval);
+               sval = typeValueEmpty;
+            }
+            type = TypeInternalFloat;
+         }
+         else
+         {
+            const char* dptr = Con::getData(TypeF32, &val, 0);
+            Con::setData(type, dataPtr, 0, 1, &dptr, enumTable);
          }
 
-         value.setString(newValue);
-
          // Fire off the notification if we have one.
          if (notify)
             notify->trigger();
       }
+
+      void setStringValue(const char* value);
    };
 
    struct HashTableData