//-----------------------------------------------
//	Hawk Reflex ERP
//	Copyright (c) 2007 - 2008 Sysmart S.R.L.
//	
//	This code is the property of Sysmart S.R.L.
//	Do not copy, distribute, or modify this code. 
//	Un-licensed use of this code is prohibited.
//-----------------------------------------------

if (typeof(Object_toJSONString) == 'undefined') {

    Array_toJSONString = function (that) {
        var a = [],     // The array holding the partial texts.
            i,          // Loop counter.
            l = that.length,
            v;          // The value to be stringified.

        for (i = 0; i < l; i += 1) {
            v = that[i];
			a.push(Object_toJSONString(v));
        }

        return '[' + a.join(',') + ']';
    };


    Boolean_toJSONString = function (that) {
        return String(that);
    };


    Date_toJSONString = function (that) {

        function f(n) {
            return n < 10 ? '0' + n : n;
        }

        return '"' + that.getUTCFullYear() + '-' +
                f(that.getUTCMonth() + 1) + '-' +
                f(that.getUTCDate()) + 'T' +
                f(that.getUTCHours()) + ':' +
                f(that.getUTCMinutes()) + ':' +
                f(that.getUTCSeconds()) + 'Z"';
    };


    Number_toJSONString = function (that) {
		
        return isFinite(that) ? String(that) : 'null';
    };


    Object_toJSONString = function (that) {
        var a = [],     // The array holding the partial texts.
            k,          // The current key.
            v;          // The current value.

		if (that === null)
			return 'null';
			
		var t = objectTypeOf(that);
		switch (t)
		{
			case 'array':	 	return Array_toJSONString(that);
			case 'string': 		return String_toJSONString(that);
			case 'date': 		return Date_toJSONString(that);
			case 'number': 		return Number_toJSONString(that);
			case 'boolean': 	return Boolean_toJSONString(that);
		}
			
// Iterate through all of the keys in the object, ignoring the proto chain
// and keys that are not strings.

        for (k in that) {
            if (typeof k === 'string' &&
                    Object.prototype.hasOwnProperty.apply(that, [k])) {
                v = that[k];
				a.push(Object_toJSONString(v));
            }
        }

// Join all of the member texts together and wrap them in braces.

        return '{' + a.join(',') + '}';
    };


    {

// Augment String.prototype. We do this in an immediate anonymous function to
// avoid defining global variables.

// m is a table of character substitutions.

        var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        };


        String_parseJSON = function (that, filter) {
            var j;

            function walk(k, v) {
                var i;
                if (v && typeof v === 'object') {
                    for (i in v) {
                        if (Object.prototype.hasOwnProperty.apply(v, [i])) {
                            v[i] = walk(i, v[i]);
                        }
                    }
                }
                return filter(k, v);
            }


// Parsing happens in three stages. In the first stage, we run the text against
// a regular expression which looks for non-JSON characters. We are especially
// concerned with '()' and 'new' because they can cause invocation, and '='
// because it can cause mutation. But just to be safe, we will reject all
// unexpected characters.

// We split the first stage into 3 regexp operations in order to work around
// crippling deficiencies in Safari's regexp engine. First we replace all
// backslash pairs with '@' (a non-JSON character). Second we delete all of
// the string literals. Third, we look to see if only JSON characters
// remain. If so, then the text is safe for eval.

            if (/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/.test(that.
                    replace(/\\./g, '@').
                    replace(/"[^"\\\n\r]*"/g, ''))) {

// In the second stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.

                j = eval('(' + that + ')');

// In the optional third stage, we recursively walk the new structure, passing
// each name/value pair to a filter function for possible transformation.

                return typeof filter === 'function' ? walk('', j) : j;
            }

// If the text is not JSON parseable, then a SyntaxError is thrown.

            throw new SyntaxError('parseJSON');
        };


        String_toJSONString = function (that) {

// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can simply slap some quotes around it.
// Otherwise we must also replace the offending characters with safe
// sequences.

            if (/["\\\x00-\x1f]/.test(that)) {
                return '"' + that.replace(/[\x00-\x1f\\"]/g, function (a) {																	
                    var c = m[a];
                    if (c) {
                        return c;
                    }
                    c = a.charCodeAt();
                    return '\\u00' +
                        Math.floor(c / 16).toString(16) +
                        (c % 16).toString(16);
                }) + '"';
            }
            return '"' + that + '"';
        };
	}
}