new console functions: SortWords() and SortNumbers()

[b]usage:[/b]
SortWords  (<space     -delimited list of words  >, [ignoreCase = true], [increasing = true])
SortFields (<tab       -delimited list of words  >, [ignoreCase = true], [increasing = true])
SortRecords(<newline   -delimited list of words  >, [ignoreCase = true], [increasing = true])
SortNumbers(<whitespace-delimited list of numbers>, [increasing = true])

note the difference between actual space (space) and whitespace (space, tab, cr or nl)

ConsoleFunctionGroupBegin( Sorting, "Functions for sorting words, numbers, etc.");

static bool sIgnoreCase;
static bool sIncreasing;

static S32 QSORT_CALLBACK qSortCallbackTextCompare(const void* a, const void* b)
{
   StringTableEntry* ea = (StringTableEntry*)(a);
   StringTableEntry* eb = (StringTableEntry*)(b);
   S32 result;
   
   if (sIgnoreCase)
      result = dStricmp(*ea, *eb);
   else
      result = dStrcmp (*ea, *eb);

   if (!sIncreasing)
      result = -result;

   return result;
}

static S32 QSORT_CALLBACK qSortCallbackFloatCompare(const void* a, const void* b)
{
   float* ea = (float*)(a);
   float* eb = (float*)(b);
   
   S32 result;
   
   // note we are comparing floats, and will *NEVER* return "equal".
   result = (*ea < *eb) ? -1 : 1;

   if (!sIncreasing)
      result = -result;

   return result;
}

const char* SortUnits(const char* units, bool ignoreCase, bool increasing, const char* delimiter)
{
   sIgnoreCase = ignoreCase;
   sIncreasing = increasing;

   // extract the words
   S32 numItems = getUnitCount(units, delimiter);

   if (numItems < 2)
      return units;

   char** items  = new char*[numItems];

   for (S32 n = 0; n < numItems; n++)
   {
      const char* item = getUnit(units, n, delimiter);
      items[n]         = dStrdup(item);
   }

   // actually do some work
   dQsort((void *)items, numItems, sizeof(*items), qSortCallbackTextCompare);

   // put em into a return buffer
   char *ret = Con::getReturnBuffer(dStrlen(units) + 1);
   ret[0]    = '[[6281528f2d2e3]]';

   for (S32 n = 0; n < numItems; n++)
   {
      if (n > 0)
         dStrcat(ret, delimiter);
      dStrcat(ret, items[n]);
   }

   // free the array
   for (S32 n = 0; n < numItems; n++)
      dFree(items[n]);

   delete [] items;

   return ret;
}

ConsoleFunction(SortWords, const char *, 2, 4,"SortWords(words, [ignoreCase=true], [increasing=true])")
{
   bool ignoreCase = true;
   bool increasing = true;

   if (argc > 2)
      ignoreCase = dAtob(argv[2]);

   if (argc > 3)
      increasing = dAtob(argv[3]);

   return SortUnits(argv[1], ignoreCase, increasing, " ");
}

ConsoleFunction(SortFields, const char *, 2, 4,"SortFields(words, [ignoreCase=true], [increasing=true])")
{
   bool ignoreCase = true;
   bool increasing = true;

   if (argc > 2)
      ignoreCase = dAtob(argv[2]);

   if (argc > 3)
      increasing = dAtob(argv[3]);

   return SortUnits(argv[1], ignoreCase, increasing, "\t");
}

ConsoleFunction(SortRecords, const char *, 2, 4,"SortRecords(words, [ignoreCase=true], [increasing=true])")
{
   bool ignoreCase = true;
   bool increasing = true;

   if (argc > 2)
      ignoreCase = dAtob(argv[2]);

   if (argc > 3)
      increasing = dAtob(argv[3]);

   return SortUnits(argv[1], ignoreCase, increasing, "\n\r");
}

ConsoleFunction(SortNumbers, const char *, 2, 4,"SortNumbers(numbers, [increasing=true])")
{
   // extract the numbers as floats.
   S32 numItems = getUnitCount(argv[1], " \t\n\r");

   if (numItems < 2)
      return argv[1];

   F32* items  = new F32[numItems];

   for (S32 n = 0; n < numItems; n++)
   {
      const char* item = getUnit(argv[1], n, " \t\n\r");
      items[n]         = dAtof(item);
   }


   // get our optional arguments
   if (argc > 2)
      sIncreasing = dAtob(argv[2]);
   else
      sIncreasing = true;


   // actually do some work
   dQsort((void*)items, numItems, sizeof(*items), qSortCallbackFloatCompare);


   // put em into a return buffer
   char  buf[16];  // should be enough room, neh ? 13 is the largest i see: "1.23456e+789 "
   char *ret = Con::getReturnBuffer(numItems * sizeof(buf) + 1);
   ret[0]    = '[[6281528f2d2e3]]';

   for (S32 n = 0; n < numItems; n++)
   {
      if (n > 0)
         dSprintf(buf, sizeof(buf), " %g", items[n]);
      else
         dSprintf(buf, sizeof(buf), "%g" , items[n]);

      dStrcat(ret, buf);
   }


   // free the array
   delete [] items;

   return ret;
}
ConsoleFunctionGroupEnd( Sorting );

==>echo(SortWords("dog cat Orion mouse 100 37"));
100 37 cat dog mouse Orion

==>echo(SortWords("dog cat Orion mouse 100 37", false));
100 37 Orion cat dog mouse

==>echo(SortWords("dog cat Orion mouse 100 37", true, false));
Orion mouse dog cat 37 100

==>echo(SortNumbers("100 37 2.3 -2.3 -3.2"));
-3.2 -2.3 2.3 37 100

==>echo(SortNumbers("100 37 2.3 -2.3 -3.2", false));
100 37 2.3 -2.3 -3.2