function numberorder(a, b) { return a - b; }

function setDataType(cValue) {
    // THIS FUNCTION CONVERTS DATES AND NUMBERS FOR PROPER ARRAY
    // SORTING WHEN IN THE SORT FUNCTION
    var new_val = cValue.replace(/,/g, "");

    if (isNaN(new_val)) {
        new_val = cValue.replace(/\-/g, " ");

        var isDate = new Date(new_val);
        // alert (isDate);
        if (isDate == "NaN") {
            // THE VALUE IS A STRING, MAKE ALL CHARACTERS IN
            // STRING UPPER CASE TO ASSURE PROPER A-Z SORT
            cValue = cValue.toUpperCase();
            return cValue;
        }
        else {
            return isDate
        }
    }
    else {
        // VALUE IS A NUMBER
        return new_val;
    }
}
function sortTable(col, tableToSort) {
    var iCurCell = col + tableToSort.cols;
    var totalRows = tableToSort.rows.length;
    var bSort = 0;
    var colArray = new Array();
    var oldIndex = new Array();
    var indexArray = new Array();
    var bArray = new Array();
    var newRow;
    var newCell;
    var i;
    var c;
    var j;

    var a_number = 1;

    // ** POPULATE THE ARRAY colArray WITH CONTENTS OF THE COLUMN SELECTED
    for (i=1; i < tableToSort.rows.length; i++) {
        // colArray[i - 1] = setDataType(tableToSort.cells(iCurCell).innerText);

        c = setDataType(tableToSort.cells(iCurCell).innerText);
        if (isNaN(c)) { a_number = 0; }
        colArray[i - 1] = c;
        iCurCell = iCurCell + tableToSort.cols;
    }
    // alert (colArray);

    // ** COPY ARRAY FOR COMPARISON AFTER SORT
    for (i=0; i < colArray.length; i++) {
        bArray[i] = colArray[i];
    }

    // ** SORT THE COLUMN ITEMS
    if (a_number == 0) {
       colArray.sort();
    }
    else {
       colArray.sort(numberorder);
    }

    // ** Check that sort changed order, else reverse
    j = 0;
    for (i=0; i < colArray.length; i++) {
        if (bArray[i] != colArray[i]) { 
           j = 1;
           break;
        }
    }

    if (j == 0) {
       // ** REVERSE SORT THE COLUMN ITEMS
       if (a_number == 0) {
          colArray.reverse();
       }
       else {
          colArray.reverse(numberorder);
       }
    }

    for (i=0; i < colArray.length; i++) {
        // LOOP THROUGH THE NEW SORTED ARRAY
        indexArray[i] = (i+1);

        for (j=0; j < bArray.length; j++) {
            // LOOP THROUGH THE OLD ARRAY
            if (colArray[i] == bArray[j]) {
                // WHEN THE ITEM IN THE OLD AND NEW MATCH, PLACE THE
                // CURRENT ROW NUMBER IN THE PROPER POSITION IN THE
                // NEW ORDER ARRAY SO ROWS CAN BE MOVED ....
                // MAKE SURE CURRENT ROW NUMBER IS NOT ALREADY IN THE
                // NEW ORDER ARRAY
                for (c=0; c<i; c++) {
                    if ( oldIndex[c] == (j+1) ) {
                      bSort = 1;
                    }
                }
                if (bSort == 0) {
                   oldIndex[i] = (j+1);
                }
                bSort = 0;
            }
        }
    }

  // ** SORTING COMPLETE, ADD NEW ROWS TO BASE OF TABLE ....
  for (i=0; i<oldIndex.length; i++) {
      newRow = tableToSort.insertRow();
      for (c=0; c<tableToSort.cols; c++) {
          newCell = newRow.insertCell();
          newCell.innerHTML = tableToSort.rows(oldIndex[i]).cells(c).innerHTML;
          newCell.className = tableToSort.rows(oldIndex[i]).cells(c).className;
          newCell.setAttribute("align", tableToSort.rows(oldIndex[i]).cells(c).getAttribute("align"));
      }
  }

  //MOVE NEW ROWS TO TOP OF TABLE ....
  for (i=1; i<totalRows; i++) {
      tableToSort.moveRow((tableToSort.rows.length -1),1);
  }

  //DELETE THE OLD ROWS FROM THE BOTTOM OF THE TABLE ....
  for (i=1; i<totalRows; i++) {
      tableToSort.deleteRow();
  }
}