/*
parseJSON(string,filter)
A slightly modified version of the public domain method 
at http://www.json.org/json.js This method parses a JSON text 
to produce an object or array. It can throw a 
SyntaxError exception.

The optional filter parameter is a function which can filter and
transform the results. It receives each of the keys and values, and
its return value is used instead of the original value. If it
returns what it received, then structure is not modified. If it
returns undefined then the member is deleted.

Example:

// Parse the text. If a key contains the string ‘date‘ then
// convert the value to a date.

myData = parseJSON(string,function (key, value) {
    return key.indexOf(‘date‘) >= 0 ? new Date(value) : value;
});

*/
function parseJSON(s,filter) {
    var j;

    function walk(k, v) {
        var i;
        if (v && typeof v === ‘object‘) {
            for (i in v) {
                if (v.hasOwnProperty(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.
/*解析通过三个极端进行：
1，通过正则表达式检测JSON文本，查找非JSON字符。其中特别关注“0”和“new”，
因为他们会引起语句的调用，还有“=”因为他会导致变量的值发生改变，不过为安全起见
这里会拒绝所有不希望出现的字符
*/
 if (/^("(\\.|[^"\\\n\r])*?"|[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t])+?$/.
            test(s)) {

// 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.
/*

*/
        try {
            j = eval(‘(‘ + s + ‘)‘);
        } catch (e) {
            throw new SyntaxError("parseJSON");
        }
    } else {
        throw new SyntaxError("parseJSON");
    }

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

    if (typeof filter === ‘function‘) {
        j = walk(‘‘, j);
    }
    return j;
};
    
        
/**
 * Setup the various parts of an XMLHttpRequest Object 
 */
function getRequestObject(url,options) {
    
    // Initialize the request object
    var req = false;
    if(window.XMLHttpRequest) {
        var req = new window.XMLHttpRequest();
    } else if (window.ActiveXObject) {
        var req = new window.ActiveXObject(‘Microsoft.XMLHTTP‘);
    }
    if(!req) return false;
    
    // Define the default options
    options = options || {};
    options.method = options.method || ‘GET‘;
    options.send = options.send || null;

    // Define the various listeners for each state of the request
    req.onreadystatechange = function() {
        switch (req.readyState) {
            case 1:
                // Loading
                if(options.loadListener) {
                    options.loadListener.apply(req,arguments);
                }
                break;
            case 2:
                // Loaded
                if(options.loadedListener) {
                    options.loadedListener.apply(req,arguments);
                }
                break;
            case 3:
                // Interactive
                if(options.ineractiveListener) {
                    options.ineractiveListener.apply(req,arguments);
                }
                break;
            case 4:
                // Complete
                // if aborted FF throws errors
                try { 
                if (req.status && req.status == 200) {
                    
                    // Specific listeners for content-type
                    // The Content-Type header can include the charset:
                    // Content-Type: text/html; charset=ISO-8859-4
                    // So we‘ll use a match to extract the part we need.
                    var contentType = req.getResponseHeader(‘Content-Type‘);
                    var mimeType = contentType.match(/\s*([^;]+)\s*(;|$)/i)[1];
                                        
                    switch(mimeType) {
                        case ‘text/javascript‘:
                        case ‘application/javascript‘:
                            // The response is JavaScript so use the 
                            // req.responseText as the argument to the callback
                            if(options.jsResponseListener) {
                                options.jsResponseListener.call(
                                    req,
                                    req.responseText
                                );
                            }
                            break;
                        case ‘application/json‘:
                            // The response is json so parse   
                            // req.responseText using the an anonymous functions
                            // which simply returns the JSON object for the
                            // argument to the callback
                            if(options.jsonResponseListener) {
                                try {
                                    var json = parseJSON(
                                        req.responseText
                                    );
                                } catch(e) {
                                    var json = false;
                                }
                                options.jsonResponseListener.call(
                                    req,
                                    json
                                );
                            }
                            break;
                        case ‘text/xml‘:
                        case ‘application/xml‘:
                        case ‘application/xhtml+xml‘:
                            // The response is XML so use the 
                            // req.responseXML as the argument to the callback
                            // This will be a Document object
                            if(options.xmlResponseListener) {
                                options.xmlResponseListener.call(
                                    req,
                                    req.responseXML
                                );
                            }
                            break;
                        case ‘text/html‘:
                            // The response is HTML so use the 
                            // req.responseText as the argument to the callback
                            if(options.htmlResponseListener) {
                                options.htmlResponseListener.call(
                                    req,
                                    req.responseText
                                );
                            }
                            break;
                    }
                
                    // A complete listener
                    if(options.completeListener) {
                        options.completeListener.apply(req,arguments);
                    }

                } else {
                    // Response completed but there was an error
                    if(options.errorListener) {
                        options.errorListener.apply(req,arguments);
                    }
                }
                

                } catch(e) {
                    //ignore errors
                    //alert(‘Response Error: ‘ + e);
                }
                break;
        }
    };
    // Open the request
    req.open(options.method, url, true);
    // Add a special header to identify the requests
    req.setRequestHeader(‘X-ADS-Ajax-Request‘,‘AjaxRequest‘);
    return req;
}
window[‘ADS‘][‘getRequestObject‘] = getRequestObject;