home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_340 < prev    next >
Encoding:
Text File  |  2011-06-06  |  14.2 KB  |  372 lines
  1. // Domain Public by Eric Wendelin http://eriwen.com/ (2008)
  2. //                  Luke Smith http://lucassmith.name/ (2008)
  3. //                  Loic Dachary <loic@dachary.org> (2008)
  4. //                  Johan Euphrosine <proppy@aminche.com> (2008)
  5. //                  Oyvind Sean Kinsey http://kinsey.no/blog (2010)
  6. //                  Victor Homyakov <victor-homyakov@users.sourceforge.net> (2010)
  7. //
  8. // Information and discussions
  9. // http://jspoker.pokersource.info/skin/test-printstacktrace.html
  10. // http://eriwen.com/javascript/js-stack-trace/
  11. // http://eriwen.com/javascript/stacktrace-update/
  12. // http://pastie.org/253058
  13. //
  14. // guessFunctionNameFromLines comes from firebug
  15. //
  16. // Software License Agreement (BSD License)
  17. //
  18. // Copyright (c) 2007, Parakey Inc.
  19. // All rights reserved.
  20. //
  21. // Redistribution and use of this software in source and binary forms, with or without modification,
  22. // are permitted provided that the following conditions are met:
  23. //
  24. // * Redistributions of source code must retain the above
  25. //   copyright notice, this list of conditions and the
  26. //   following disclaimer.
  27. //
  28. // * Redistributions in binary form must reproduce the above
  29. //   copyright notice, this list of conditions and the
  30. //   following disclaimer in the documentation and/or other
  31. //   materials provided with the distribution.
  32. //
  33. // * Neither the name of Parakey Inc. nor the names of its
  34. //   contributors may be used to endorse or promote products
  35. //   derived from this software without specific prior
  36. //   written permission of Parakey Inc.
  37. //
  38. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
  39. // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  40. // FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  41. // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  42. // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  43. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  44. // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45. // OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  46.  
  47. /**
  48.  * Main function giving a function stack trace with a forced or passed in Error
  49.  *
  50.  * @cfg {Error} e The error to create a stacktrace from (optional)
  51.  * @cfg {Boolean} guess If we should try to resolve the names of anonymous functions
  52.  * @return {Array} of Strings with functions, lines, files, and arguments where possible
  53.  */
  54. function printStackTrace(options) {
  55.     options = options || {guess: true};
  56.     var ex = options.e || null, guess = !!options.guess;
  57.     var p = new printStackTrace.implementation(), result = p.run(ex);
  58.     return (guess) ? p.guessAnonymousFunctions(result) : result;
  59. }
  60.  
  61. printStackTrace.implementation = function() {
  62. };
  63.  
  64. printStackTrace.implementation.prototype = {
  65.     run: function(ex) {
  66.         ex = ex || this.createException();
  67.         // Do not use the stored mode: different exceptions in Chrome
  68.         // may or may not have arguments or stack
  69.         var mode = this.mode(ex);
  70.         // Use either the stored mode, or resolve it
  71.         //var mode = this._mode || this.mode(ex);
  72.         if (mode === 'other') {
  73.             return this.other(arguments.callee);
  74.         } else {
  75.             return this[mode](ex);
  76.         }
  77.     },
  78.  
  79.     createException: function() {
  80.         try {
  81.             this.undef();
  82.             return null;
  83.         } catch (e) {
  84.             return e;
  85.         }
  86.     },
  87.  
  88.     /**
  89.      * @return {String} mode of operation for the environment in question.
  90.      */
  91.     mode: function(e) {
  92.         if (e['arguments'] && e.stack) {
  93.             return (this._mode = 'chrome');
  94.         } else if (e.message && typeof window !== 'undefined' && window.opera) {
  95.             return (this._mode = e.stacktrace ? 'opera10' : 'opera');
  96.         } else if (e.stack) {
  97.             return (this._mode = 'firefox');
  98.         }
  99.         return (this._mode = 'other');
  100.     },
  101.  
  102.     /**
  103.      * Given a context, function name, and callback function, overwrite it so that it calls
  104.      * printStackTrace() first with a callback and then runs the rest of the body.
  105.      *
  106.      * @param {Object} context of execution (e.g. window)
  107.      * @param {String} functionName to instrument
  108.      * @param {Function} function to call with a stack trace on invocation
  109.      */
  110.     instrumentFunction: function(context, functionName, callback) {
  111.         context = context || window;
  112.         var original = context[functionName];
  113.         context[functionName] = function instrumented() {
  114.             callback.call(this, printStackTrace().slice(4));
  115.             return context[functionName]._instrumented.apply(this, arguments);
  116.         };
  117.         context[functionName]._instrumented = original;
  118.     },
  119.  
  120.     /**
  121.      * Given a context and function name of a function that has been
  122.      * instrumented, revert the function to it's original (non-instrumented)
  123.      * state.
  124.      *
  125.      * @param {Object} context of execution (e.g. window)
  126.      * @param {String} functionName to de-instrument
  127.      */
  128.     deinstrumentFunction: function(context, functionName) {
  129.         if (context[functionName].constructor === Function &&
  130.                 context[functionName]._instrumented &&
  131.                 context[functionName]._instrumented.constructor === Function) {
  132.             context[functionName] = context[functionName]._instrumented;
  133.         }
  134.     },
  135.  
  136.     /**
  137.      * Given an Error object, return a formatted Array based on Chrome's stack string.
  138.      *
  139.      * @param e - Error object to inspect
  140.      * @return Array<String> of function calls, files and line numbers
  141.      */
  142.     chrome: function(e) {
  143.         //return e.stack.replace(/^[^\(]+?[\n$]/gm, '').replace(/^\s+at\s+/gm, '').replace(/^Object.<anonymous>\s*\(/gm, '{anonymous}()@').split('\n');
  144.         return e.stack.replace(/^\S[^\(]+?[\n$]/gm, '').
  145.           replace(/^\s+at\s+/gm, '').
  146.           replace(/^([^\(]+?)([\n$])/gm, '{anonymous}()@$1$2').
  147.           replace(/^Object.<anonymous>\s*\(([^\)]+)\)/gm, '{anonymous}()@$1').split('\n');
  148.     },
  149.  
  150.     /**
  151.      * Given an Error object, return a formatted Array based on Firefox's stack string.
  152.      *
  153.      * @param e - Error object to inspect
  154.      * @return Array<String> of function calls, files and line numbers
  155.      */
  156.     firefox: function(e) {
  157.         return e.stack.replace(/(?:\n@:0)?\s+$/m, '').replace(/^\(/gm, '{anonymous}(').split('\n');
  158.     },
  159.  
  160.     /**
  161.      * Given an Error object, return a formatted Array based on Opera 10's stacktrace string.
  162.      *
  163.      * @param e - Error object to inspect
  164.      * @return Array<String> of function calls, files and line numbers
  165.      */
  166.     opera10: function(e) {
  167.         var stack = e.stacktrace;
  168.         var lines = stack.split('\n'), ANON = '{anonymous}', lineRE = /.*line (\d+), column (\d+) in ((<anonymous function\:?\s*(\S+))|([^\(]+)\([^\)]*\))(?: in )?(.*)\s*$/i, i, j, len;
  169.         for (i = 2, j = 0, len = lines.length; i < len - 2; i++) {
  170.             if (lineRE.test(lines[i])) {
  171.                 var location = RegExp.$6 + ':' + RegExp.$1 + ':' + RegExp.$2;
  172.                 var fnName = RegExp.$3;
  173.                 fnName = fnName.replace(/<anonymous function\:?\s?(\S+)?>/g, ANON);
  174.                 lines[j++] = fnName + '@' + location;
  175.             }
  176.         }
  177.  
  178.         lines.splice(j, lines.length - j);
  179.         return lines;
  180.     },
  181.  
  182.     // Opera 7.x-9.x only!
  183.     opera: function(e) {
  184.         var lines = e.message.split('\n'), ANON = '{anonymous}', lineRE = /Line\s+(\d+).*script\s+(http\S+)(?:.*in\s+function\s+(\S+))?/i, i, j, len;
  185.  
  186.         for (i = 4, j = 0, len = lines.length; i < len; i += 2) {
  187.             //TODO: RegExp.exec() would probably be cleaner here
  188.             if (lineRE.test(lines[i])) {
  189.                 lines[j++] = (RegExp.$3 ? RegExp.$3 + '()@' + RegExp.$2 + RegExp.$1 : ANON + '()@' + RegExp.$2 + ':' + RegExp.$1) + ' -- ' + lines[i + 1].replace(/^\s+/, '');
  190.             }
  191.         }
  192.  
  193.         lines.splice(j, lines.length - j);
  194.         return lines;
  195.     },
  196.  
  197.     // Safari, IE, and others
  198.     other: function(curr) {
  199.         var ANON = '{anonymous}', fnRE = /function\s*([\w\-$]+)?\s*\(/i, stack = [], fn, args, maxStackSize = 10;
  200.         while (curr && stack.length < maxStackSize) {
  201.             fn = fnRE.test(curr.toString()) ? RegExp.$1 || ANON : ANON;
  202.             args = Array.prototype.slice.call(curr['arguments'] || []);
  203.             stack[stack.length] = fn + '(' + this.stringifyArguments(args) + ')';
  204.             curr = curr.caller;
  205.         }
  206.         return stack;
  207.     },
  208.  
  209.     /**
  210.      * Given arguments array as a String, subsituting type names for non-string types.
  211.      *
  212.      * @param {Arguments} object
  213.      * @return {Array} of Strings with stringified arguments
  214.      */
  215.     stringifyArguments: function(args) {
  216.         var slice = Array.prototype.slice;
  217.         for (var i = 0; i < args.length; ++i) {
  218.             var arg = args[i];
  219.             if (arg === undefined) {
  220.                 args[i] = 'undefined';
  221.             } else if (arg === null) {
  222.                 args[i] = 'null';
  223.             } else if (arg.constructor) {
  224.                 if (arg.constructor === Array) {
  225.                     if (arg.length < 3) {
  226.                         args[i] = '[' + this.stringifyArguments(arg) + ']';
  227.                     } else {
  228.                         args[i] = '[' + this.stringifyArguments(slice.call(arg, 0, 1)) + '...' + this.stringifyArguments(slice.call(arg, -1)) + ']';
  229.                     }
  230.                 } else if (arg.constructor === Object) {
  231.                     args[i] = '#object';
  232.                 } else if (arg.constructor === Function) {
  233.                     args[i] = '#function';
  234.                 } else if (arg.constructor === String) {
  235.                     args[i] = '"' + arg + '"';
  236.                 }
  237.             }
  238.         }
  239.         return args.join(',');
  240.     },
  241.  
  242.     sourceCache: {},
  243.  
  244.     /**
  245.      * @return the text from a given URL.
  246.      */
  247.     ajax: function(url) {
  248.         var req = this.createXMLHTTPObject();
  249.         if (!req) {
  250.             return;
  251.         }
  252.         req.open('GET', url, false);
  253.         req.setRequestHeader('User-Agent', 'XMLHTTP/1.0');
  254.         req.send('');
  255.         return req.responseText;
  256.     },
  257.  
  258.     /**
  259.      * Try XHR methods in order and store XHR factory.
  260.      *
  261.      * @return <Function> XHR function or equivalent
  262.      */
  263.     createXMLHTTPObject: function() {
  264.         var xmlhttp, XMLHttpFactories = [
  265.             function() {
  266.                 return new XMLHttpRequest();
  267.             }, function() {
  268.                 return new ActiveXObject('Msxml2.XMLHTTP');
  269.             }, function() {
  270.                 return new ActiveXObject('Msxml3.XMLHTTP');
  271.             }, function() {
  272.                 return new ActiveXObject('Microsoft.XMLHTTP');
  273.             }
  274.         ];
  275.         for (var i = 0; i < XMLHttpFactories.length; i++) {
  276.             try {
  277.                 xmlhttp = XMLHttpFactories[i]();
  278.                 // Use memoization to cache the factory
  279.                 this.createXMLHTTPObject = XMLHttpFactories[i];
  280.                 return xmlhttp;
  281.             } catch (e) {
  282.             }
  283.         }
  284.     },
  285.  
  286.     /**
  287.      * Given a URL, check if it is in the same domain (so we can get the source
  288.      * via Ajax).
  289.      *
  290.      * @param url <String> source url
  291.      * @return False if we need a cross-domain request
  292.      */
  293.     isSameDomain: function(url) {
  294.         return url.indexOf(location.hostname) !== -1;
  295.     },
  296.  
  297.     /**
  298.      * Get source code from given URL if in the same domain.
  299.      *
  300.      * @param url <String> JS source URL
  301.      * @return <Array> Array of source code lines
  302.      */
  303.     getSource: function(url) {
  304.         if (!(url in this.sourceCache)) {
  305.             this.sourceCache[url] = this.ajax(url).split('\n');
  306.         }
  307.         return this.sourceCache[url];
  308.     },
  309.  
  310.     guessAnonymousFunctions: function(stack) {
  311.         for (var i = 0; i < stack.length; ++i) {
  312.             var reStack = /\{anonymous\}\(.*\)@(\w+:\/\/([\-\w\.]+)+(:\d+)?[^:]+):(\d+):?(\d+)?/;
  313.             var frame = stack[i], m = reStack.exec(frame);
  314.             if (m) {
  315.                 var file = m[1], lineno = m[4], charno = m[7] || 0; //m[7] is character position in Chrome
  316.                 if (file && this.isSameDomain(file) && lineno) {
  317.                     var functionName = this.guessAnonymousFunction(file, lineno, charno);
  318.                     stack[i] = frame.replace('{anonymous}', functionName);
  319.                 }
  320.             }
  321.         }
  322.         return stack;
  323.     },
  324.  
  325.     guessAnonymousFunction: function(url, lineNo, charNo) {
  326.         var ret;
  327.         try {
  328.             ret = this.findFunctionName(this.getSource(url), lineNo);
  329.         } catch (e) {
  330.             ret = 'getSource failed with url: ' + url + ', exception: ' + e.toString();
  331.         }
  332.         return ret;
  333.     },
  334.  
  335.     findFunctionName: function(source, lineNo) {
  336.         // FIXME findFunctionName fails for compressed source
  337.         // (more than one function on the same line)
  338.         // TODO use captured args
  339.         // function {name}({args}) m[1]=name m[2]=args
  340.         var reFunctionDeclaration = /function\s+([^(]*?)\s*\(([^)]*)\)/;
  341.         // {name} = function ({args}) TODO args capture
  342.         // /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*function(?:[^(]*)/
  343.         var reFunctionExpression = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*function\b/;
  344.         // {name} = eval()
  345.         var reFunctionEvaluation = /['"]?([0-9A-Za-z_]+)['"]?\s*[:=]\s*(?:eval|new Function)\b/;
  346.         // Walk backwards in the source lines until we find
  347.         // the line which matches one of the patterns above
  348.         var code = "", line, maxLines = 10, m;
  349.         for (var i = 0; i < maxLines; ++i) {
  350.             // FIXME lineNo is 1-based, source[] is 0-based
  351.             line = source[lineNo - i];
  352.             if (line) {
  353.                 code = line + code;
  354.                 m = reFunctionExpression.exec(code);
  355.                 if (m && m[1]) {
  356.                     return m[1];
  357.                 }
  358.                 m = reFunctionDeclaration.exec(code);
  359.                 if (m && m[1]) {
  360.                     //return m[1] + "(" + (m[2] || "") + ")";
  361.                     return m[1];
  362.                 }
  363.                 m = reFunctionEvaluation.exec(code);
  364.                 if (m && m[1]) {
  365.                     return m[1];
  366.                 }
  367.             }
  368.         }
  369.         return '(?)';
  370.     }
  371. };
  372.