//-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------

#include <unordered_map>

#include "platform/platform.h"
#include "console/console.h"

#include "console/ast.h"
#include "core/tAlgorithm.h"

#include "core/strings/findMatch.h"
#include "console/consoleInternal.h"
#include "core/stream/fileStream.h"
#include "console/compiler.h"
#include "console/engineAPI.h"

//#define DEBUG_SPEW

#define ST_INIT_SIZE 15

static char scratchBuffer[1024];
U32 Namespace::mCacheSequence = 0;
DataChunker Namespace::mCacheAllocator;
DataChunker Namespace::mAllocator;
Namespace *Namespace::mNamespaceList = NULL;
Namespace *Namespace::mGlobalNamespace = NULL;

namespace std
{
   template<> struct hash<std::pair<StringTableEntry, StringTableEntry>>
   {
      typedef std::pair<StringTableEntry, StringTableEntry> argument_type;
      typedef size_t result_type;
      result_type operator()(argument_type const& s) const
      {
         return HashPointer(s.first) ^ (HashPointer(s.second) << 1);
      }
   };
};

std::unordered_map<std::pair<StringTableEntry, StringTableEntry>, Namespace*> gNamespaceCache;

bool canTabComplete(const char *prevText, const char *bestMatch,
   const char *newText, S32 baseLen, bool fForward)
{
   // test if it matches the first baseLen chars:
   if (dStrnicmp(newText, prevText, baseLen))
      return false;

   if (fForward)
   {
      if (!bestMatch)
         return dStricmp(newText, prevText) > 0;
      else
         return (dStricmp(newText, prevText) > 0) &&
         (dStricmp(newText, bestMatch) < 0);
   }
   else
   {
      if (dStrlen(prevText) == (U32)baseLen)
      {
         // look for the 'worst match'
         if (!bestMatch)
            return dStricmp(newText, prevText) > 0;
         else
            return dStricmp(newText, bestMatch) > 0;
      }
      else
      {
         if (!bestMatch)
            return (dStricmp(newText, prevText)  < 0);
         else
            return (dStricmp(newText, prevText)  < 0) &&
            (dStricmp(newText, bestMatch) > 0);
      }
   }
}

//---------------------------------------------------------------
//
// Dictionary functions
//
//---------------------------------------------------------------
struct StringValue
{
   S32 size;
   char *val;

   operator char *() { return val; }
   StringValue &operator=(const char *string);

   StringValue() { size = 0; val = NULL; }
   ~StringValue() { dFree(val); }
};


StringValue & StringValue::operator=(const char *string)
{
   if (!val)
   {
      val = dStrdup(string);
      size = dStrlen(val);
   }
   else
   {
      S32 len = dStrlen(string);
      if (len < size)
         dStrcpy(val, string, size);
      else
      {
         size = len;
         dFree(val);
         val = dStrdup(string);
      }
   }
   return *this;
}

static S32 QSORT_CALLBACK varCompare(const void* a, const void* b)
{
   return dStricmp((*((Dictionary::Entry **) a))->name, (*((Dictionary::Entry **) b))->name);
}

void Dictionary::exportVariables(const char *varString, const char *fileName, bool append)
{
   const char *searchStr = varString;
   Vector<Entry *> sortList(__FILE__, __LINE__);

   for (S32 i = 0; i < hashTable->size; i++)
   {
      Entry *walk = hashTable->data[i];
      while (walk)
      {
         if (FindMatch::isMatch((char *)searchStr, (char *)walk->name))
            sortList.push_back(walk);

         walk = walk->nextEntry;
      }
   }

   if (!sortList.size())
      return;

   dQsort((void *)&sortList[0], sortList.size(), sizeof(Entry *), varCompare);

   Vector<Entry *>::iterator s;
   char expandBuffer[1024];
   FileStream *strm = NULL;

   if (fileName)
   {
      if ((strm = FileStream::createAndOpen(fileName, append ? Torque::FS::File::ReadWrite : Torque::FS::File::Write)) == NULL)
      {
         Con::errorf(ConsoleLogEntry::General, "Unable to open file '%s for writing.", fileName);
         return;
      }
      if (append)
         strm->setPosition(strm->getStreamSize());
   }

   char buffer[1024];
   const char *cat = fileName ? "\r\n" : "";

   for (s = sortList.begin(); s != sortList.end(); s++)
   {
      switch ((*s)->type)
      {
         case Entry::TypeInternalInt:
            dSprintf(buffer, sizeof(buffer), "%s = %d;%s", (*s)->name, (*s)->ival, cat);
            break;
         case Entry::TypeInternalFloat:
            dSprintf(buffer, sizeof(buffer), "%s = %g;%s", (*s)->name, (*s)->fval, cat);
            break;
         default:
            expandEscape(expandBuffer, (*s)->getStringValue());
            dSprintf(buffer, sizeof(buffer), "%s = \"%s\";%s", (*s)->name, expandBuffer, cat);
            break;
      }
      if (strm)
         strm->write(dStrlen(buffer), buffer);
      else
         Con::printf("%s", buffer);
   }
   if (strm)
      delete strm;
}

void Dictionary::exportVariables(const char *varString, Vector<String> *names, Vector<String> *values)
{
   const char *searchStr = varString;
   Vector<Entry *> sortList(__FILE__, __LINE__);

   for (S32 i = 0; i < hashTable->size; i++)
   {
      Entry *walk = hashTable->data[i];
      while (walk)
      {
         if (FindMatch::isMatch((char*)searchStr, (char*)walk->name))
            sortList.push_back(walk);

         walk = walk->nextEntry;
      }
   }

   if (!sortList.size())
      return;

   dQsort((void *)&sortList[0], sortList.size(), sizeof(Entry *), varCompare);

   if (names)
      names->reserve(sortList.size());
   if (values)
      values->reserve(sortList.size());

   char expandBuffer[1024];

   Vector<Entry *>::iterator s;

   for (s = sortList.begin(); s != sortList.end(); s++)
   {
      if (names)
         names->push_back(String((*s)->name));

      if (values)
      {
         switch ((*s)->type)
         {
            case ConsoleValueType::cvInteger:
            case ConsoleValueType::cvFloat:
               values->push_back(String((*s)->getStringValue()));
               break;
            default:
               expandEscape(expandBuffer, (*s)->getStringValue());
               values->push_back(expandBuffer);
               break;
         }
      }
   }
}

void Dictionary::deleteVariables(const char *varString)
{
   const char *searchStr = varString;

   for (S32 i = 0; i < hashTable->size; i++)
   {
      Entry *walk = hashTable->data[i];
      while (walk)
      {
         Entry *matchedEntry = (FindMatch::isMatch((char *)searchStr, (char *)walk->name)) ? walk : NULL;
         walk = walk->nextEntry;
         if (matchedEntry)
            remove(matchedEntry); // assumes remove() is a stable remove (will not reorder entries on remove)
      }
   }
}

U32 HashPointer(StringTableEntry ptr)
{
   return (U32)(((dsize_t)ptr) >> 2);
}

Dictionary::Entry *Dictionary::lookup(StringTableEntry name)
{
   Entry *walk = hashTable->data[HashPointer(name) % hashTable->size];
   while (walk)
   {
      if (walk->name == name)
         return walk;
      else
         walk = walk->nextEntry;
   }

   return NULL;
}

Dictionary::Entry *Dictionary::add(StringTableEntry name)
{
   // Try to find an existing match.
   //printf("Add Variable %s\n", name);

   Entry* ret = lookup(name);
   if (ret)
      return ret;

   // Rehash if the table get's too crowded.  Be aware that this might
   // modify a table that we don't own.

   hashTable->count++;
   if (hashTable->count > hashTable->size * 2)
   {
      // Allocate a new table.

      const U32 newTableSize = hashTable->size * 4 - 1;
      Entry** newTableData = new Entry*[newTableSize];
      dMemset(newTableData, 0, newTableSize * sizeof(Entry*));

      // Move the entries over.

      for (U32 i = 0; i < hashTable->size; ++i)
         for (Entry* entry = hashTable->data[i]; entry != NULL; )
         {
            Entry* next = entry->nextEntry;
            U32 index = HashPointer(entry->name) % newTableSize;

            entry->nextEntry = newTableData[index];
            newTableData[index] = entry;

            entry = next;
         }

      // Switch the tables.

      delete[] hashTable->data;
      hashTable->data = newTableData;
      hashTable->size = newTableSize;
   }

#ifdef DEBUG_SPEW
   Platform::outputDebugString("[ConsoleInternal] Adding entry '%s'", name);
#endif

   // Add the new entry.

   ret = hashTable->mChunker.alloc();
   constructInPlace(ret, name);
   U32 idx = HashPointer(name) % hashTable->size;
   ret->nextEntry = hashTable->data[idx];
   hashTable->data[idx] = ret;

   return ret;
}

// deleteVariables() assumes remove() is a stable remove (will not reorder entries on remove)
void Dictionary::remove(Dictionary::Entry *ent)
{
   Entry **walk = &hashTable->data[HashPointer(ent->name) % hashTable->size];
   while (*walk != ent)
      walk = &((*walk)->nextEntry);

#ifdef DEBUG_SPEW
   Platform::outputDebugString("[ConsoleInternal] Removing entry '%s'", ent->name);
#endif

   *walk = (ent->nextEntry);

   destructInPlace(ent);
   hashTable->mChunker.free(ent);

   hashTable->count--;
}

Dictionary::Dictionary()
   : hashTable(NULL),
#pragma warning( disable : 4355 )
   ownHashTable(this), // Warning with VC++ but this is safe.
#pragma warning( default : 4355 )
   exprState(NULL),
   scopeName(NULL),
   scopeNamespace(NULL),
   code(NULL),
   ip(0)
{
}

void Dictionary::setState(ExprEvalState *state, Dictionary* ref)
{
   exprState = state;

   if (ref)
   {
      hashTable = ref->hashTable;
      return;
   }

   if (!ownHashTable.data)
   {
      ownHashTable.count = 0;
      ownHashTable.size = ST_INIT_SIZE;
      ownHashTable.data = new Entry *[ownHashTable.size];

      dMemset(ownHashTable.data, 0, ownHashTable.size * sizeof(Entry*));
   }

   hashTable = &ownHashTable;
}

Dictionary::~Dictionary()
{
   reset();
   if (ownHashTable.data)
      delete[] ownHashTable.data;
}

void Dictionary::reset()
{
   if (hashTable && hashTable->owner != this)
   {
      hashTable = NULL;
      return;
   }

   for (U32 i = 0; i < ownHashTable.size; ++i)
   {
      Entry* walk = ownHashTable.data[i];
      while (walk)
      {
         Entry* temp = walk->nextEntry;
         destructInPlace(walk);
         walk = temp;
      }
   }

   dMemset(ownHashTable.data, 0, ownHashTable.size * sizeof(Entry*));
   ownHashTable.mChunker.freeBlocks(true);

   ownHashTable.count = 0;
   hashTable = NULL;

   scopeName = NULL;
   scopeNamespace = NULL;
   code = NULL;
   ip = 0;
}


const char *Dictionary::tabComplete(const char *prevText, S32 baseLen, bool fForward)
{
   S32 i;

   const char *bestMatch = NULL;
   for (i = 0; i < hashTable->size; i++)
   {
      Entry *walk = hashTable->data[i];
      while (walk)
      {
         if (canTabComplete(prevText, bestMatch, walk->name, baseLen, fForward))
            bestMatch = walk->name;
         walk = walk->nextEntry;
      }
   }
   return bestMatch;
}


char *typeValueEmpty = "";

Dictionary::Entry::Entry(StringTableEntry in_name)
{
   name = in_name;
   type = TypeInternalString;
   notify = NULL;
   nextEntry = NULL;
   mUsage = NULL;
   mIsConstant = false;
   mNext = NULL;

   ival = 0;
   fval = 0;
   sval = typeValueEmpty;
   bufferLen = 0;
}

Dictionary::Entry::~Entry()
{
   reset();
}

void Dictionary::Entry::reset()
{
   name = NULL;
   if (type <= TypeInternalString && sval != typeValueEmpty)
      dFree(sval);
   if (notify)
      delete notify;
}

void Dictionary::Entry::setStringValue(const char* value)
{
   if (mIsConstant)
   {
      Con::errorf("Cannot assign value to constant '%s'.", name);
      return;
   }

   if (type <= TypeInternalString)
   {
      // Let's not remove empty-string-valued global vars from the dict.
      // If we remove them, then they won't be exported, and sometimes
      // it could be necessary to export such a global.  There are very
      // few empty-string global vars so there's no performance-related
      // need to remove them from the dict.
      /*
       if(!value[0] && name[0] == '$')
       {
       gEvalState.globalVars.remove(this);
       return;
       }
       */

      U32 stringLen = dStrlen(value);

      // If it's longer than 256 bytes, it's certainly not a number.
      //
      // (This decision may come back to haunt you. Shame on you if it
      // does.)
      if (stringLen < 256)
      {
         fval = dAtof(value);
         ival = dAtoi(value);
      }
      else
      {
         fval = 0.f;
         ival = 0;
      }

      type = TypeInternalString;

      // may as well pad to the next cache line
      U32 newLen = ((stringLen + 1) + 15) & ~15;

      if (sval == typeValueEmpty)
         sval = (char*)dMalloc(newLen);
      else if (newLen > bufferLen)
         sval = (char*)dRealloc(sval, newLen);

      bufferLen = newLen;
      dStrcpy(sval, value, newLen);
   }
   else
      Con::setData(type, dataPtr, 0, 1, &value, enumTable);

   // Fire off the notification if we have one.
   if (notify)
      notify->trigger();
}

const char *Dictionary::getVariable(StringTableEntry name, bool *entValid)
{
   Entry *ent = lookup(name);
   if (ent)
   {
      if (entValid)
         *entValid = true;
      return ent->getStringValue();
   }
   if (entValid)
      *entValid = false;

   // Warn users when they access a variable that isn't defined.
   if (gWarnUndefinedScriptVariables)
      Con::warnf(" *** Accessed undefined variable '%s'", name);

   return "";
}

S32 Dictionary::getIntVariable(StringTableEntry name, bool *entValid)
{
   Entry *ent = lookup(name);
   if (ent)
   {
      if (entValid)
         *entValid = true;
      return ent->getIntValue();
   }

   if (entValid)
      *entValid = false;

   return 0;
}

F32 Dictionary::getFloatVariable(StringTableEntry name, bool *entValid)
{
   Entry *ent = lookup(name);
   if (ent)
   {
      if (entValid)
         *entValid = true;
      return ent->getFloatValue();
   }

   if (entValid)
      *entValid = false;

   return 0;
}

void Dictionary::setVariable(StringTableEntry name, const char *value)
{
   Entry *ent = add(name);
   if (!value)
      value = "";
   ent->setStringValue(value);
}

Dictionary::Entry* Dictionary::addVariable(const char *name,
   S32 type,
   void *dataPtr,
   const char* usage)
{
   AssertFatal(type >= 0, "Dictionary::addVariable - Got bad type!");

   if (name[0] != '$')
   {
      scratchBuffer[0] = '$';
      dStrcpy(scratchBuffer + 1, name, 1023);
      name = scratchBuffer;
   }

   Entry *ent = add(StringTable->insert(name));

   if (ent->type <= Entry::TypeInternalString && ent->sval != typeValueEmpty)
      dFree(ent->sval);

   ent->mUsage = usage;
   ent->type = type;
   ent->dataPtr = dataPtr;

   // Fetch enum table, if any.
   ConsoleBaseType* conType = ConsoleBaseType::getType(type);
   AssertFatal(conType, "Dictionary::addVariable - invalid console type");
   ent->enumTable = conType->getEnumTable();

   return ent;
}

bool Dictionary::removeVariable(StringTableEntry name)
{
   if (Entry *ent = lookup(name))
   {
      remove(ent);
      return true;
   }
   return false;
}

void Dictionary::addVariableNotify(const char *name, const Con::NotifyDelegate &callback)
{
   Entry *ent = lookup(StringTable->insert(name));
   if (!ent)
      return;

   if (!ent->notify)
      ent->notify = new Entry::NotifySignal();

   ent->notify->notify(callback);
}

void Dictionary::removeVariableNotify(const char *name, const Con::NotifyDelegate &callback)
{
   Entry *ent = lookup(StringTable->insert(name));
   if (ent && ent->notify)
      ent->notify->remove(callback);
}

void Dictionary::validate()
{
   AssertFatal(ownHashTable.owner == this,
      "Dictionary::validate() - Dictionary not owner of own hashtable!");
}

void ExprEvalState::pushFrame(StringTableEntry frameName, Namespace *ns, S32 registerCount)
{
#ifdef DEBUG_SPEW
   validate();

   Platform::outputDebugString("[ConsoleInternal] Pushing new frame for '%s' at %i",
      frameName, mStackDepth);
#endif

   if (mStackDepth + 1 > stack.size())
   {
#ifdef DEBUG_SPEW
      Platform::outputDebugString("[ConsoleInternal] Growing stack by one frame");
#endif

      stack.push_back(new Dictionary);
   }

   Dictionary& newFrame = *(stack[mStackDepth]);
   newFrame.setState(this);

   newFrame.scopeName = frameName;
   newFrame.scopeNamespace = ns;

   mStackDepth++;
   currentVariable = NULL;

   AssertFatal(!newFrame.getCount(), "ExprEvalState::pushFrame - Dictionary not empty!");

   ConsoleValue* consoleValArray = new ConsoleValue[registerCount]();
   localStack.push_back(ConsoleValueFrame(consoleValArray, false));
   currentRegisterArray = &localStack.last();

   AssertFatal(mStackDepth == localStack.size(), avar("Stack sizes do not match. mStackDepth = %d, localStack = %d", mStackDepth, localStack.size()));

#ifdef DEBUG_SPEW
   validate();
#endif
}

void ExprEvalState::popFrame()
{
   AssertFatal(mStackDepth > 0, "ExprEvalState::popFrame - Stack Underflow!");

#ifdef DEBUG_SPEW
   validate();

   Platform::outputDebugString("[ConsoleInternal] Popping %sframe at %i",
      getCurrentFrame().isOwner() ? "" : "shared ", mStackDepth - 1);
#endif

   mStackDepth--;
   stack[mStackDepth]->reset();
   currentVariable = NULL;

   const ConsoleValueFrame& frame = localStack.last();
   localStack.pop_back();
   if (!frame.isReference)
      delete[] frame.values;

   currentRegisterArray = localStack.size() ? &localStack.last() : NULL;

   AssertFatal(mStackDepth == localStack.size(), avar("Stack sizes do not match. mStackDepth = %d, localStack = %d", mStackDepth, localStack.size()));

#ifdef DEBUG_SPEW
   validate();
#endif
}

void ExprEvalState::pushFrameRef(S32 stackIndex)
{
   AssertFatal(stackIndex >= 0 && stackIndex < mStackDepth, "You must be asking for a valid frame!");

#ifdef DEBUG_SPEW
   validate();

   Platform::outputDebugString("[ConsoleInternal] Cloning frame from %i to %i",
      stackIndex, mStackDepth);
#endif

   if (mStackDepth + 1 > stack.size())
   {
#ifdef DEBUG_SPEW
      Platform::outputDebugString("[ConsoleInternal] Growing stack by one frame");
#endif

      stack.push_back(new Dictionary);
   }

   Dictionary& newFrame = *(stack[mStackDepth]);
   newFrame.setState(this, stack[stackIndex]);

   mStackDepth++;
   currentVariable = NULL;

   ConsoleValue* values = localStack[stackIndex].values;
   localStack.push_back(ConsoleValueFrame(values, true));
   currentRegisterArray = &localStack.last();

   AssertFatal(mStackDepth == localStack.size(), avar("Stack sizes do not match. mStackDepth = %d, localStack = %d", mStackDepth, localStack.size()));

#ifdef DEBUG_SPEW
   validate();
#endif
}

void ExprEvalState::pushDebugFrame(S32 stackIndex)
{
   pushFrameRef(stackIndex);

   Dictionary& newFrame = *(stack[mStackDepth - 1]);

   // debugger needs to know this info...
   newFrame.scopeName = stack[stackIndex]->scopeName;
   newFrame.scopeNamespace = stack[stackIndex]->scopeNamespace;
   newFrame.code = stack[stackIndex]->code;
   newFrame.ip = stack[stackIndex]->ip;
}

ExprEvalState::ExprEvalState()
{
   VECTOR_SET_ASSOCIATION(stack);
   globalVars.setState(this);
   thisObject = NULL;
   traceOn = false;
   currentVariable = NULL;
   mStackDepth = 0;
   stack.reserve(64);
   mShouldReset = false;
   mResetLocked = false;
   copyVariable = NULL;
}

ExprEvalState::~ExprEvalState()
{
   // Delete callframes.

   while (!stack.empty())
   {
      delete stack.last();
      stack.decrement();
   }
}

void ExprEvalState::validate()
{
   AssertFatal(mStackDepth <= stack.size(),
      "ExprEvalState::validate() - Stack depth pointing beyond last stack frame!");

   for (U32 i = 0; i < stack.size(); ++i)
      stack[i]->validate();
}

DefineEngineFunction(backtrace, void, (), ,
   "@brief Prints the scripting call stack to the console log.\n\n"
   "Used to trace functions called from within functions. Can help discover what functions were called "
   "(and not yet exited) before the current point in scripts.\n\n"
   "@ingroup Debugging")
{
   U32 totalSize = 1;

   for (U32 i = 0; i < gEvalState.getStackDepth(); i++)
   {
      if (gEvalState.stack[i]->scopeNamespace && gEvalState.stack[i]->scopeNamespace->mEntryList->mPackage)
         totalSize += dStrlen(gEvalState.stack[i]->scopeNamespace->mEntryList->mPackage) + 2;
      if (gEvalState.stack[i]->scopeName)
         totalSize += dStrlen(gEvalState.stack[i]->scopeName) + 3;
      if (gEvalState.stack[i]->scopeNamespace && gEvalState.stack[i]->scopeNamespace->mName)
         totalSize += dStrlen(gEvalState.stack[i]->scopeNamespace->mName) + 2;
   }

   char *buf = Con::getReturnBuffer(totalSize);
   buf[0] = 0;
   for (U32 i = 0; i < gEvalState.getStackDepth(); i++)
   {
      dStrcat(buf, "->", totalSize);

      if (gEvalState.stack[i]->scopeNamespace && gEvalState.stack[i]->scopeNamespace->mEntryList->mPackage)
      {
         dStrcat(buf, "[", totalSize);
         dStrcat(buf, gEvalState.stack[i]->scopeNamespace->mEntryList->mPackage, totalSize);
         dStrcat(buf, "]", totalSize);
      }
      if (gEvalState.stack[i]->scopeNamespace && gEvalState.stack[i]->scopeNamespace->mName)
      {
         dStrcat(buf, gEvalState.stack[i]->scopeNamespace->mName, totalSize);
         dStrcat(buf, "::", totalSize);
      }
      if (gEvalState.stack[i]->scopeName)
         dStrcat(buf, gEvalState.stack[i]->scopeName, totalSize);
   }

   Con::printf("BackTrace: %s", buf);
}

Namespace::Entry::Entry()
{
   mCode = NULL;
   mType = InvalidFunctionType;
   mUsage = NULL;
   mHeader = NULL;
   mNamespace = NULL;
   cb.mStringCallbackFunc = NULL;
   mFunctionLineNumber = 0;
   mFunctionName = StringTable->EmptyString();
   mFunctionOffset = 0;
   mMinArgs = 0;
   mMaxArgs = 0;
   mNext = NULL;
   mPackage = StringTable->EmptyString();
   mToolOnly = false;
}

void Namespace::Entry::clear()
{
   if (mCode)
   {
      mCode->decRefCount();
      mCode = NULL;
   }

   // Clean up usage strings generated for script functions.
   if ((mType == Namespace::Entry::ConsoleFunctionType) && mUsage)
   {
      dFree(mUsage);
      mUsage = NULL;
   }
}

Namespace::Namespace()
{
   mPackage = NULL;
   mUsage = NULL;
   mCleanUpUsage = false;
   mName = NULL;
   mParent = NULL;
   mNext = NULL;
   mEntryList = NULL;
   mHashSize = 0;
   mHashTable = 0;
   mHashSequence = 0;
   mRefCountToParent = 0;
   mClassRep = 0;
   lastUsage = NULL;
}

Namespace::~Namespace()
{
   clearEntries();
   if (mUsage && mCleanUpUsage)
   {
      dFree(mUsage);
      mUsage = NULL;
      mCleanUpUsage = false;
   }
}

void Namespace::clearEntries()
{
   for (Entry *walk = mEntryList; walk; walk = walk->mNext)
      walk->clear();
}

Namespace *Namespace::find(StringTableEntry name, StringTableEntry package)
{
   if (name == NULL && package == NULL)
      return mGlobalNamespace;

   auto pair = std::make_pair(name, package);
   auto pos = gNamespaceCache.find(pair);
   if (pos != gNamespaceCache.end())
      return pos->second;

   Namespace *ret = (Namespace *)mAllocator.alloc(sizeof(Namespace));
   constructInPlace(ret);
   ret->mPackage = package;
   ret->mName = name;
   ret->mNext = mNamespaceList;
   mNamespaceList = ret;

   // insert into namespace cache.
   gNamespaceCache[pair] = ret;

   return ret;
}

bool Namespace::unlinkClass(Namespace *parent)
{
   AssertFatal(mPackage == NULL, "Namespace::unlinkClass - Must not be called on a namespace coming from a package!");

   // Skip additions to this namespace coming from packages.

   Namespace* walk = getPackageRoot();

   // Make sure "parent" is the direct parent namespace.

   if (parent != NULL && walk->mParent && walk->mParent != parent)
   {
      Con::errorf(ConsoleLogEntry::General, "Namespace::unlinkClass - cannot unlink namespace parent linkage for %s for %s.",
         walk->mName, walk->mParent->mName);
      return false;
   }

   // Decrease the reference count.  Note that we do this on
   // the bottom-most namespace, i.e. the one guaranteed not 
   // to come from a package.

   mRefCountToParent--;
   AssertFatal(mRefCountToParent >= 0, "Namespace::unlinkClass - reference count to parent is less than 0");

   // Unlink if the count dropped to zero.

   if (mRefCountToParent == 0)
   {
      walk->mParent = NULL;
      trashCache();
   }

   return true;
}


bool Namespace::classLinkTo(Namespace *parent)
{
   Namespace* walk = getPackageRoot();

   if (walk->mParent && walk->mParent != parent)
   {
      Con::errorf(ConsoleLogEntry::General, "Error: cannot change namespace parent linkage of %s from %s to %s.",
         walk->mName, walk->mParent->mName, parent->mName);
      return false;
   }

   trashCache();
   walk->mParent = parent;

   mRefCountToParent++;

   return true;
}

void Namespace::buildHashTable()
{
   if (mHashSequence == mCacheSequence)
      return;

   if (!mEntryList && mParent)
   {
      mParent->buildHashTable();
      mHashTable = mParent->mHashTable;
      mHashSize = mParent->mHashSize;
      mHashSequence = mCacheSequence;
      return;
   }

   U32 entryCount = 0;
   Namespace * ns;
   for (ns = this; ns; ns = ns->mParent)
      for (Entry *walk = ns->mEntryList; walk; walk = walk->mNext)
         if (lookupRecursive(walk->mFunctionName) == walk)
            entryCount++;

   mHashSize = entryCount + (entryCount >> 1) + 1;

   if (!(mHashSize & 1))
      mHashSize++;

   mHashTable = (Entry **)mCacheAllocator.alloc(sizeof(Entry *) * mHashSize);
   for (U32 i = 0; i < mHashSize; i++)
      mHashTable[i] = NULL;

   for (ns = this; ns; ns = ns->mParent)
   {
      for (Entry *walk = ns->mEntryList; walk; walk = walk->mNext)
      {
         U32 index = HashPointer(walk->mFunctionName) % mHashSize;
         while (mHashTable[index] && mHashTable[index]->mFunctionName != walk->mFunctionName)
         {
            index++;
            if (index >= mHashSize)
               index = 0;
         }

         if (!mHashTable[index])
            mHashTable[index] = walk;
      }
   }

   mHashSequence = mCacheSequence;
}

void Namespace::getUniqueEntryLists(Namespace *other, VectorPtr<Entry *> *outThisList, VectorPtr<Entry *> *outOtherList)
{
   // All namespace entries in the common ACR should be
   // ignored when checking for duplicate entry names.
   static VectorPtr<Namespace::Entry *> commonEntries;
   commonEntries.clear();

   AbstractClassRep *commonACR = mClassRep->getCommonParent(other->mClassRep);
   commonACR->getNameSpace()->getEntryList(&commonEntries);

   // Make life easier
   VectorPtr<Namespace::Entry *> &thisEntries = *outThisList;
   VectorPtr<Namespace::Entry *> &compEntries = *outOtherList;

   // Clear, just in case they aren't
   thisEntries.clear();
   compEntries.clear();

   getEntryList(&thisEntries);
   other->getEntryList(&compEntries);

   // Run through all of the entries in the common ACR, and remove them from
   // the other two entry lists
   for (NamespaceEntryListIterator itr = commonEntries.begin(); itr != commonEntries.end(); itr++)
   {
      // Check this entry list
      for (NamespaceEntryListIterator thisItr = thisEntries.begin(); thisItr != thisEntries.end(); thisItr++)
      {
         if (*thisItr == *itr)
         {
            thisEntries.erase(thisItr);
            break;
         }
      }

      // Same check for component entry list
      for (NamespaceEntryListIterator compItr = compEntries.begin(); compItr != compEntries.end(); compItr++)
      {
         if (*compItr == *itr)
         {
            compEntries.erase(compItr);
            break;
         }
      }
   }
}

void Namespace::init()
{
   // create the global namespace
   mGlobalNamespace = (Namespace *)mAllocator.alloc(sizeof(Namespace));
   constructInPlace(mGlobalNamespace);
   mGlobalNamespace->mPackage = NULL;
   mGlobalNamespace->mName = NULL;
   mGlobalNamespace->mNext = NULL;
   mNamespaceList = mGlobalNamespace;

   // Insert into namespace cache.
   gNamespaceCache[std::make_pair(mGlobalNamespace->mName, mGlobalNamespace->mPackage)] = mGlobalNamespace;
}

Namespace *Namespace::global()
{
   return mGlobalNamespace;
}

void Namespace::shutdown()
{
   // The data chunker will release all memory in one go
   // without calling destructors, so we do this manually here.

   for (Namespace *walk = mNamespaceList; walk; walk = walk->mNext)
      walk->~Namespace();
}

void Namespace::trashCache()
{
   mCacheSequence++;
   mCacheAllocator.freeBlocks();
}

const char *Namespace::tabComplete(const char *prevText, S32 baseLen, bool fForward)
{
   if (mHashSequence != mCacheSequence)
      buildHashTable();

   const char *bestMatch = NULL;
   for (U32 i = 0; i < mHashSize; i++)
      if (mHashTable[i] && canTabComplete(prevText, bestMatch, mHashTable[i]->mFunctionName, baseLen, fForward))
         bestMatch = mHashTable[i]->mFunctionName;
   return bestMatch;
}

Namespace::Entry *Namespace::lookupRecursive(StringTableEntry name)
{
   for (Namespace *ns = this; ns; ns = ns->mParent)
      for (Entry *walk = ns->mEntryList; walk; walk = walk->mNext)
         if (walk->mFunctionName == name)
            return walk;

   return NULL;
}

Namespace::Entry *Namespace::lookup(StringTableEntry name)
{
   if (mHashSequence != mCacheSequence)
      buildHashTable();

   U32 index = HashPointer(name) % mHashSize;
   while (mHashTable[index] && mHashTable[index]->mFunctionName != name)
   {
      index++;
      if (index >= mHashSize)
         index = 0;
   }
   return mHashTable[index];
}

static S32 QSORT_CALLBACK compareEntries(const void* a, const void* b)
{
   const Namespace::Entry* fa = *((Namespace::Entry**)a);
   const Namespace::Entry* fb = *((Namespace::Entry**)b);

   return dStricmp(fa->mFunctionName, fb->mFunctionName);
}

void Namespace::getEntryList(VectorPtr<Entry *> *vec)
{
   if (mHashSequence != mCacheSequence)
      buildHashTable();

   for (U32 i = 0; i < mHashSize; i++)
      if (mHashTable[i])
         vec->push_back(mHashTable[i]);

   dQsort(vec->address(), vec->size(), sizeof(Namespace::Entry *), compareEntries);
}

Namespace::Entry *Namespace::createLocalEntry(StringTableEntry name)
{
   for (Entry *walk = mEntryList; walk; walk = walk->mNext)
   {
      if (walk->mFunctionName == name)
      {
         walk->clear();
         return walk;
      }
   }

   Entry *ent = (Entry *)mAllocator.alloc(sizeof(Entry));
   constructInPlace(ent);

   ent->mNamespace = this;
   ent->mFunctionName = name;
   ent->mNext = mEntryList;
   ent->mPackage = mPackage;
   ent->mToolOnly = false;
   mEntryList = ent;
   return ent;
}

void Namespace::addFunction(StringTableEntry name, CodeBlock *cb, U32 functionOffset, const char* usage, U32 lineNumber)
{
   Entry *ent = createLocalEntry(name);
   trashCache();

   ent->mUsage = usage;
   ent->mCode = cb;
   ent->mFunctionOffset = functionOffset;
   ent->mCode->incRefCount();
   ent->mType = Entry::ConsoleFunctionType;
   ent->mFunctionLineNumber = lineNumber;
}

void Namespace::addCommand(StringTableEntry name, StringCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header)
{
   Entry *ent = createLocalEntry(name);
   trashCache();

   ent->mUsage = usage;
   ent->mHeader = header;
   ent->mMinArgs = minArgs;
   ent->mMaxArgs = maxArgs;
   ent->mToolOnly = isToolOnly;

   ent->mType = Entry::StringCallbackType;
   ent->cb.mStringCallbackFunc = cb;
}

void Namespace::addCommand(StringTableEntry name, IntCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header)
{
   Entry *ent = createLocalEntry(name);
   trashCache();

   ent->mUsage = usage;
   ent->mHeader = header;
   ent->mMinArgs = minArgs;
   ent->mMaxArgs = maxArgs;
   ent->mToolOnly = isToolOnly;

   ent->mType = Entry::IntCallbackType;
   ent->cb.mIntCallbackFunc = cb;
}

void Namespace::addCommand(StringTableEntry name, VoidCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header)
{
   Entry *ent = createLocalEntry(name);
   trashCache();

   ent->mUsage = usage;
   ent->mHeader = header;
   ent->mMinArgs = minArgs;
   ent->mMaxArgs = maxArgs;
   ent->mToolOnly = isToolOnly;

   ent->mType = Entry::VoidCallbackType;
   ent->cb.mVoidCallbackFunc = cb;
}

void Namespace::addCommand(StringTableEntry name, FloatCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header)
{
   Entry *ent = createLocalEntry(name);
   trashCache();

   ent->mUsage = usage;
   ent->mHeader = header;
   ent->mMinArgs = minArgs;
   ent->mMaxArgs = maxArgs;
   ent->mToolOnly = isToolOnly;

   ent->mType = Entry::FloatCallbackType;
   ent->cb.mFloatCallbackFunc = cb;
}

void Namespace::addCommand(StringTableEntry name, BoolCallback cb, const char *usage, S32 minArgs, S32 maxArgs, bool isToolOnly, ConsoleFunctionHeader* header)
{
   Entry *ent = createLocalEntry(name);
   trashCache();

   ent->mUsage = usage;
   ent->mHeader = header;
   ent->mMinArgs = minArgs;
   ent->mMaxArgs = maxArgs;
   ent->mToolOnly = isToolOnly;

   ent->mType = Entry::BoolCallbackType;
   ent->cb.mBoolCallbackFunc = cb;
}

void Namespace::addScriptCallback(const char *funcName, const char *usage, ConsoleFunctionHeader* header)
{
   static U32 uid = 0;
   char buffer[1024];
   char lilBuffer[32];
   dStrcpy(buffer, funcName, 1024);
   dSprintf(lilBuffer, 32, "_%d_cb", uid++);
   dStrcat(buffer, lilBuffer, 1024);

   Entry *ent = createLocalEntry(StringTable->insert(buffer));
   trashCache();

   ent->mUsage = usage;
   ent->mHeader = header;
   ent->mMinArgs = -2;
   ent->mMaxArgs = -3;

   ent->mType = Entry::ScriptCallbackType;
   ent->cb.mCallbackName = funcName;
}

void Namespace::markGroup(const char* name, const char* usage)
{
   static U32 uid = 0;
   char buffer[1024];
   char lilBuffer[32];
   dStrcpy(buffer, name, 1024);
   dSprintf(lilBuffer, 32, "_%d", uid++);
   dStrcat(buffer, lilBuffer, 1024);

   Entry *ent = createLocalEntry(StringTable->insert(buffer));
   trashCache();

   if (usage != NULL)
      lastUsage = (char*)(ent->mUsage = usage);
   else
      ent->mUsage = lastUsage;

   ent->mMinArgs = -1; // Make sure it explodes if somehow we run this entry.
   ent->mMaxArgs = -2;

   ent->mType = Entry::GroupMarker;
   ent->cb.mGroupName = name;
}

extern S32 executeBlock(StmtNode *block, ExprEvalState *state);

ConsoleValue Namespace::Entry::execute(S32 argc, ConsoleValue *argv, ExprEvalState *state)
{
   STR.clearFunctionOffset();

   if (mType == ConsoleFunctionType)
   {
      if (mFunctionOffset)
      {
         return std::move(mCode->exec(mFunctionOffset, argv[0].getString(), mNamespace, argc, argv, false, mPackage));
      }
      else
      {
         return std::move(ConsoleValue());
      }
   }

#ifndef TORQUE_DEBUG
   // [tom, 12/13/2006] This stops tools functions from working in the console,
   // which is useful behavior when debugging so I'm ifdefing this out for debug builds.
   if (mToolOnly && !Con::isCurrentScriptToolScript())
   {
      Con::errorf(ConsoleLogEntry::Script, "%s::%s - attempting to call tools only function from outside of tools", mNamespace->mName, mFunctionName);
      return std::move(ConsoleValue());
   }
#endif

   if ((mMinArgs && argc < mMinArgs) || (mMaxArgs && argc > mMaxArgs))
   {
      Con::warnf(ConsoleLogEntry::Script, "%s::%s - wrong number of arguments.", mNamespace->mName, mFunctionName);
      Con::warnf(ConsoleLogEntry::Script, "usage: %s", mUsage);
      return std::move(ConsoleValue());
   }

   ConsoleValue result;
   switch (mType)
   {
      case StringCallbackType:
      {
         const char* str = cb.mStringCallbackFunc(state->thisObject, argc, argv);
         result.setString(str);
         break;
      }
      case IntCallbackType:
         result.setInt(cb.mIntCallbackFunc(state->thisObject, argc, argv));
         break;
      case FloatCallbackType:
         result.setFloat(cb.mFloatCallbackFunc(state->thisObject, argc, argv));
         break;
      case VoidCallbackType:
         cb.mVoidCallbackFunc(state->thisObject, argc, argv);
         break;
      case BoolCallbackType:
         result.setBool(cb.mBoolCallbackFunc(state->thisObject, argc, argv));
         break;
   }

   return std::move(result);
}

//-----------------------------------------------------------------------------
// Doc string code.

namespace {

   /// Scan the given usage string for an argument list description.  With the
   /// old console macros, these were usually included as the first part of the
   /// usage string.
   bool sFindArgumentListSubstring(const char* usage, const char*& start, const char*& end)
   {
      if (!usage)
         return false;

      const char* ptr = usage;
      while (*ptr && *ptr != '(' && *ptr != '\n') // Only scan first line of usage string.
      {
         // Stop on the first alphanumeric character as we expect
         // argument lists to precede descriptions.
         if (dIsalnum(*ptr))
            return false;

         ptr++;
      }

      if (*ptr != '(')
         return false;

      start = ptr;
      ptr++;

      bool inString = false;
      U32 nestingCount = 0;

      while (*ptr && (*ptr != ')' || nestingCount > 0 || inString))
      {
         if (*ptr == '(')
            nestingCount++;
         else if (*ptr == ')')
            nestingCount--;
         else if (*ptr == '"')
            inString = !inString;
         else if (*ptr == '\\' && ptr[1] == '"')
            ptr++;
         ptr++;
      }

      if (*ptr)
         ptr++;
      end = ptr;

      return true;
   }

   ///
   void sParseList(const char* str, Vector< String >& outList)
   {
      // Skip the initial '( '.

      const char* ptr = str;
      while (*ptr && dIsspace(*ptr))
         ptr++;

      if (*ptr == '(')
      {
         ptr++;
         while (*ptr && dIsspace(*ptr))
            ptr++;
      }

      // Parse out list items.

      while (*ptr && *ptr != ')')
      {
         // Find end of element.

         const char* start = ptr;

         bool inString = false;
         U32 nestingCount = 0;

         while (*ptr && ((*ptr != ')' && *ptr != ',') || nestingCount > 0 || inString))
         {
            if (*ptr == '(')
               nestingCount++;
            else if (*ptr == ')')
               nestingCount--;
            else if (*ptr == '"')
               inString = !inString;
            else if (*ptr == '\\' && ptr[1] == '"')
               ptr++;
            ptr++;
         }

         // Backtrack to remove trailing whitespace.

         const char* end = ptr;
         if (*end == ',' || *end == ')')
            end--;
         while (end > start && dIsspace(*end))
            end--;
         if (*end)
            end++;

         // Add to list.

         if (start != end)
            outList.push_back(String(start, end - start));

         // Skip comma and whitespace.

         if (*ptr == ',')
            ptr++;
         while (*ptr && dIsspace(*ptr))
            ptr++;
      }
   }

   ///
   void sGetArgNameAndType(const String& str, String& outType, String& outName)
   {
      if (!str.length())
      {
         outType = String::EmptyString;
         outName = String::EmptyString;
         return;
      }

      // Find first non-ID character from right.

      S32 index = str.length() - 1;
      while (index >= 0 && (dIsalnum(str[index]) || str[index] == '_'))
         index--;

      const U32 nameStartIndex = index + 1;

      // Find end of type name by skipping rightmost whitespace inwards.

      while (index >= 0 && dIsspace(str[index]))
         index--;

      //

      outName = String(&((const char*)str)[nameStartIndex]);
      outType = String(str, index + 1);
   }

   /// Return the type name to show in documentation for the given C++ type.
   const char* sGetDocTypeString(const char* nativeType)
   {
      if (dStrncmp(nativeType, "const ", 6) == 0)
         nativeType += 6;

      if (String::compare(nativeType, "char*") == 0 || String::compare(nativeType, "char *") == 0)
         return "string";
      else if (String::compare(nativeType, "S32") == 0)
         return "int";
      else if (String::compare(nativeType, "U32") == 0)
         return "uint";
      else if (String::compare(nativeType, "F32") == 0)
         return "float";

      const U32 length = dStrlen(nativeType);
      if (nativeType[length - 1] == '&' || nativeType[length - 1] == '*')
         return StringTable->insertn(nativeType, length - 1);

      return nativeType;
   }
}

String Namespace::Entry::getBriefDescription(String* outRemainingDocText) const
{
   String docString = getDocString();

   S32 newline = docString.find('\n');
   if (newline == -1)
   {
      if (outRemainingDocText)
         *outRemainingDocText = String();
      return docString;
   }

   String brief = docString.substr(0, newline);
   if (outRemainingDocText)
      *outRemainingDocText = docString.substr(newline + 1);

   return brief;
}

String Namespace::Entry::getDocString() const
{
   const char* argListStart;
   const char* argListEnd;

   if (sFindArgumentListSubstring(mUsage, argListStart, argListEnd))
   {
      // Skip the " - " part present in some old doc strings.

      const char* ptr = argListEnd;
      while (*ptr && dIsspace(*ptr))
         ptr++;

      if (*ptr == '-')
      {
         ptr++;
         while (*ptr && dIsspace(*ptr))
            ptr++;
      }

      return ptr;
   }

   return mUsage;
}

String Namespace::Entry::getArgumentsString() const
{
   StringBuilder str;

   if (mHeader)
   {
      // Parse out the argument list string supplied with the extended
      // function header and add default arguments as we go.

      Vector< String > argList;
      Vector< String > defaultArgList;

      sParseList(mHeader->mArgString, argList);
      sParseList(mHeader->mDefaultArgString, defaultArgList);

      str.append('(');

      const U32 numArgs = argList.size();
      const U32 numDefaultArgs = defaultArgList.size();
      const U32 firstDefaultArgIndex = numArgs - numDefaultArgs;

      for (U32 i = 0; i < numArgs; ++i)
      {
         // Add separator if not first arg.

         if (i > 0)
            str.append(',');

         // Add type and name.

         String name;
         String type;

         sGetArgNameAndType(argList[i], type, name);

         str.append(' ');
         str.append(sGetDocTypeString(type));
         str.append(' ');
         str.append(name);

         // Add default value, if any.

         if (i >= firstDefaultArgIndex)
         {
            str.append('=');
            str.append(defaultArgList[i - firstDefaultArgIndex]);
         }
      }

      if (numArgs > 0)
         str.append(' ');
      str.append(')');
   }
   else
   {
      // No extended function header.  Try to parse out the argument
      // list from the usage string.

      const char* argListStart;
      const char* argListEnd;

      if (sFindArgumentListSubstring(mUsage, argListStart, argListEnd))
         str.append(argListStart, argListEnd - argListStart);
      else if (mType == ConsoleFunctionType && mCode)
      {
         // This isn't correct but the nonsense console stuff is set up such that all
         // functions that have no function bodies are keyed to offset 0 to indicate "no code."
         // This loses the association with the original function definition so we can't really
         // tell here what the actual prototype is except if we searched though the entire opcode
         // stream for the corresponding OP_FUNC_DECL (which would require dealing with the
         // variable-size instructions).

         if (!mFunctionOffset)
            return "()";

         String args = mCode->getFunctionArgs(mFunctionOffset);
         if (args.isEmpty())
            return "()";

         str.append("( ");
         str.append(args);
         str.append(" )");
      }
   }

   return str.end();
}

String Namespace::Entry::getPrototypeString() const
{
   StringBuilder str;

   // Start with return type.

   if (mHeader && mHeader->mReturnString)
   {
      str.append(sGetDocTypeString(mHeader->mReturnString));
      str.append(' ');
   }
   else
      switch (mType)
      {
         case StringCallbackType:
            str.append("string ");
            break;

         case IntCallbackType:
            str.append("int ");
            break;

         case FloatCallbackType:
            str.append("float ");
            break;

         case VoidCallbackType:
            str.append("void ");
            break;

         case BoolCallbackType:
            str.append("bool ");
            break;

         case ScriptCallbackType:
            break;
      }

   // Add function name and arguments.

   if (mType == ScriptCallbackType)
      str.append(cb.mCallbackName);
   else
      str.append(mFunctionName);

   str.append(getArgumentsString());

   return str.end();
}

//-----------------------------------------------------------------------------

StringTableEntry Namespace::mActivePackages[Namespace::MaxActivePackages];
U32 Namespace::mNumActivePackages = 0;
U32 Namespace::mOldNumActivePackages = 0;

bool Namespace::isPackage(StringTableEntry name)
{
   for (Namespace *walk = mNamespaceList; walk; walk = walk->mNext)
      if (walk->mPackage == name)
         return true;
   return false;
}

U32 Namespace::getActivePackagesCount()
{
   return mNumActivePackages;
}

StringTableEntry Namespace::getActivePackage(U32 index)
{
   if (index >= mNumActivePackages)
      return StringTable->EmptyString();

   return mActivePackages[index];
}

void Namespace::activatePackage(StringTableEntry name)
{
   if (mNumActivePackages == MaxActivePackages)
   {
      Con::printf("ActivatePackage(%s) failed - Max package limit reached: %d", name, MaxActivePackages);
      return;
   }
   if (!name)
      return;

   // see if this one's already active
   for (U32 i = 0; i < mNumActivePackages; i++)
      if (mActivePackages[i] == name)
         return;

   // kill the cache
   trashCache();

   // find all the package namespaces...
   for (Namespace *walk = mNamespaceList; walk; walk = walk->mNext)
   {
      if (walk->mPackage == name)
      {
         Namespace *parent = Namespace::find(walk->mName);
         // hook the parent
         walk->mParent = parent->mParent;
         parent->mParent = walk;

         // now swap the entries:
         Entry *ew;
         for (ew = parent->mEntryList; ew; ew = ew->mNext)
            ew->mNamespace = walk;

         for (ew = walk->mEntryList; ew; ew = ew->mNext)
            ew->mNamespace = parent;

         ew = walk->mEntryList;
         walk->mEntryList = parent->mEntryList;
         parent->mEntryList = ew;
      }
   }
   mActivePackages[mNumActivePackages++] = name;
}

void Namespace::deactivatePackage(StringTableEntry name)
{
   U32 oldNumActivePackages = mNumActivePackages;

   // Remove all packages down to the given one
   deactivatePackageStack(name);

   // Now add back all packages that followed the given one
   if (!oldNumActivePackages)
      return;
   for (U32 i = mNumActivePackages + 1; i < oldNumActivePackages; i++)
      activatePackage(mActivePackages[i]);
}

void Namespace::deactivatePackageStack(StringTableEntry name)
{
   S32 i, j;
   for (i = 0; i < mNumActivePackages; i++)
      if (mActivePackages[i] == name)
         break;
   if (i == mNumActivePackages)
      return;

   trashCache();

   // Remove all packages down to the given one
   for (j = mNumActivePackages - 1; j >= i; j--)
   {
      // gotta unlink em in reverse order...
      for (Namespace *walk = mNamespaceList; walk; walk = walk->mNext)
      {
         if (walk->mPackage == mActivePackages[j])
         {
            Namespace *parent = Namespace::find(walk->mName);
            // hook the parent
            parent->mParent = walk->mParent;
            walk->mParent = NULL;

            // now swap the entries:
            Entry *ew;
            for (ew = parent->mEntryList; ew; ew = ew->mNext)
               ew->mNamespace = walk;

            for (ew = walk->mEntryList; ew; ew = ew->mNext)
               ew->mNamespace = parent;

            ew = walk->mEntryList;
            walk->mEntryList = parent->mEntryList;
            parent->mEntryList = ew;
         }
      }
   }
   mNumActivePackages = i;
}

void Namespace::unlinkPackages()
{
   mOldNumActivePackages = mNumActivePackages;
   if (!mNumActivePackages)
      return;
   deactivatePackageStack(mActivePackages[0]);
}

void Namespace::relinkPackages()
{
   if (!mOldNumActivePackages)
      return;
   for (U32 i = 0; i < mOldNumActivePackages; i++)
      activatePackage(mActivePackages[i]);
}


DefineEngineFunction(isPackage, bool, (String identifier), ,
   "@brief Returns true if the identifier is the name of a declared package.\n\n"
   "@ingroup Packages\n")
{
   StringTableEntry name = StringTable->insert(identifier.c_str());
   return Namespace::isPackage(name);
}

DefineEngineFunction(activatePackage, void, (String packageName), ,
   "@brief Activates an existing package.\n\n"
   "The activation occurs by updating the namespace linkage of existing functions and methods. "
   "If the package is already activated the function does nothing.\n"
   "@ingroup Packages\n")
{
   StringTableEntry name = StringTable->insert(packageName.c_str());
   Namespace::activatePackage(name);
}

DefineEngineFunction(deactivatePackage, void, (String packageName), ,
   "@brief Deactivates a previously activated package.\n\n"
   "The package is deactivated by removing its namespace linkages to any function or method. "
   "If there are any packages above this one in the stack they are deactivated as well. "
   "If the package is not on the stack this function does nothing.\n"
   "@ingroup Packages\n")
{
   StringTableEntry name = StringTable->insert(packageName.c_str());
   Namespace::deactivatePackage(name);
}

DefineEngineFunction(getPackageList, const char*, (), ,
   "@brief Returns a space delimited list of the active packages in stack order.\n\n"
   "@ingroup Packages\n")
{
   if (Namespace::getActivePackagesCount() == 0)
      return "";

   // Determine size of return buffer
   dsize_t buffersize = 0;
   for (U32 i = 0; i < Namespace::getActivePackagesCount(); ++i)
   {
      buffersize += dStrlen(Namespace::getActivePackage(i)) + 1;
   }

   U32 maxBufferSize = buffersize + 1;
   char* returnBuffer = Con::getReturnBuffer(maxBufferSize);
   U32 returnLen = 0;
   for (U32 i = 0; i < Namespace::getActivePackagesCount(); ++i)
   {
      dSprintf(returnBuffer + returnLen, maxBufferSize - returnLen, "%s ", Namespace::getActivePackage(i));
      returnLen = dStrlen(returnBuffer);
   }

   // Trim off the last extra space
   if (returnLen > 0 && returnBuffer[returnLen - 1] == ' ')
      returnBuffer[returnLen - 1] = '\0';

   return returnBuffer;
}