| /* |
| Some portions: |
| Copyright (c) 2008, Yahoo! Inc. All rights reserved. |
| Code licensed under the BSD License: |
| http://developer.yahoo.net/yui/license.txt |
| version: 2.5.1 |
| */ |
| |
| // create org.antlr module |
| if (typeof org == "undefined" || !org) { |
| var org = {}; |
| } |
| if (typeof org.antlr == "undefined" || !org.antlr) { |
| /** |
| * The org.antlr global namespace object. If antlr is already defined, the |
| * existing antlr object will not be overwritten so that defined |
| * namespaces are preserved. |
| * @namespace org.antlr |
| */ |
| org.antlr = {}; |
| } |
| |
| /** |
| * The global JavaScript object. |
| */ |
| org.antlr.global = (function() { |
| return this; |
| }).call(null); |
| |
| /** |
| * Returns the namespace specified and creates it if it doesn't exist. |
| * |
| * Be careful when naming packages. Reserved words may work in some browsers |
| * and not others. For instance, the following will fail in Safari: |
| * <pre> |
| * org.antlr.namespace("really.long.nested.namespace"); |
| * </pre> |
| * This fails because "long" is a future reserved word in ECMAScript |
| * |
| * @static |
| * @param {Array.<String>} arguments 1-n namespaces to create |
| * @return {Object} A reference to the last namespace object created |
| * @example |
| * org.antlr.namespace("org.antlr.property.package"); |
| */ |
| org.antlr.namespace = function() { |
| var a=arguments, o=null, i, j, d; |
| for (i=0; i<a.length; i=i+1) { |
| d=a[i].split("."); |
| o=org.antlr.global; |
| |
| // ANTLR is implied, so it is ignored if it is included |
| for (j=0; j<d.length; j=j+1) { |
| o[d[j]]=o[d[j]] || {}; |
| o=o[d[j]]; |
| } |
| } |
| |
| return o; |
| }; |
| |
| /** |
| * org.antlr.env is used to keep track of what is known about the library and |
| * the browsing environment |
| * @namespace org.antlr.env |
| */ |
| org.antlr.env = org.antlr.env || {}; |
| |
| /** |
| * Do not fork for a browser if it can be avoided. Use feature detection when |
| * you can. Use the user agent as a last resort. org.antlr.env.ua stores a |
| * version number for the browser engine, 0 otherwise. This value may or may |
| * not map to the version number of the browser using the engine. The value is |
| * presented as a float so that it can easily be used for boolean evaluation |
| * as well as for looking for a particular range of versions. Because of this, |
| * some of the granularity of the version info may be lost (e.g., Gecko 1.8.0.9 |
| * reports 1.8). |
| * @namespace org.antlr.env.ua |
| */ |
| org.antlr.env.ua = function() { |
| var o= /** @lends org.antlr.env.ua */ { |
| |
| /** |
| * Internet Explorer version number or 0. Example: 6 |
| * @property ie |
| * @type float |
| */ |
| ie:0, |
| |
| /** |
| * Opera version number or 0. Example: 9.2 |
| * @property opera |
| * @type float |
| */ |
| opera:0, |
| |
| /** |
| * Gecko engine revision number. Will evaluate to 1 if Gecko |
| * is detected but the revision could not be found. Other browsers |
| * will be 0. Example: 1.8 |
| * <pre> |
| * Firefox 1.0.0.4: 1.7.8 <-- Reports 1.7 |
| * Firefox 1.5.0.9: 1.8.0.9 <-- Reports 1.8 |
| * Firefox 2.0.0.3: 1.8.1.3 <-- Reports 1.8 |
| * Firefox 3 alpha: 1.9a4 <-- Reports 1.9 |
| * </pre> |
| * @property gecko |
| * @type float |
| */ |
| gecko:0, |
| |
| /** |
| * AppleWebKit version. KHTML browsers that are not WebKit browsers |
| * will evaluate to 1, other browsers 0. Example: 418.9.1 |
| * <pre> |
| * Safari 1.3.2 (312.6): 312.8.1 <-- Reports 312.8 -- currently the |
| * latest available for Mac OSX 10.3. |
| * Safari 2.0.2: 416 <-- hasOwnProperty introduced |
| * Safari 2.0.4: 418 <-- preventDefault fixed |
| * Safari 2.0.4 (419.3): 418.9.1 <-- One version of Safari may run |
| * different versions of webkit |
| * Safari 2.0.4 (419.3): 419 <-- Tiger installations that have been |
| * updated, but not updated |
| * to the latest patch. |
| * Webkit 212 nightly: 522+ <-- Safari 3.0 precursor (with native SVG |
| * and many major issues fixed). |
| * 3.x yahoo.com, flickr:422 <-- Safari 3.x hacks the user agent |
| * string when hitting yahoo.com and |
| * flickr.com. |
| * Safari 3.0.4 (523.12):523.12 <-- First Tiger release - automatic update |
| * from 2.x via the 10.4.11 OS patch |
| * Webkit nightly 1/2008:525+ <-- Supports DOMContentLoaded event. |
| * yahoo.com user agent hack removed. |
| * |
| * </pre> |
| * http://developer.apple.com/internet/safari/uamatrix.html |
| * @property webkit |
| * @type float |
| */ |
| webkit: 0, |
| |
| /** |
| * The mobile property will be set to a string containing any relevant |
| * user agent information when a modern mobile browser is detected. |
| * Currently limited to Safari on the iPhone/iPod Touch, Nokia N-series |
| * devices with the WebKit-based browser, and Opera Mini. |
| * @property mobile |
| * @type string |
| */ |
| mobile: null, |
| |
| /** |
| * Adobe AIR version number or 0. Only populated if webkit is detected. |
| * Example: 1.0 |
| * @property air |
| * @type float |
| */ |
| air: 0, |
| |
| /** |
| * Is this the Rhino interpreter? |
| * @property rhino |
| * @type Boolean |
| */ |
| rhino: false |
| |
| }; |
| |
| var ua, m; |
| |
| try { |
| ua = navigator.userAgent; |
| |
| // Modern KHTML browsers should qualify as Safari X-Grade |
| if ((/KHTML/).test(ua)) { |
| o.webkit=1; |
| } |
| // Modern WebKit browsers are at least X-Grade |
| m=ua.match(/AppleWebKit\/([^\s]*)/); |
| if (m&&m[1]) { |
| o.webkit=parseFloat(m[1]); |
| |
| // Mobile browser check |
| if (/ Mobile\//.test(ua)) { |
| o.mobile = "Apple"; // iPhone or iPod Touch |
| } else { |
| m=ua.match(/NokiaN[^\/]*/); |
| if (m) { |
| o.mobile = m[0]; // Nokia N-series, ex: NokiaN95 |
| } |
| } |
| |
| m=ua.match(/AdobeAIR\/([^\s]*)/); |
| if (m) { |
| o.air = m[0]; // Adobe AIR 1.0 or better |
| } |
| |
| } |
| |
| if (!o.webkit) { // not webkit |
| // @todo check Opera/8.01 (J2ME/MIDP; Opera Mini/2.0.4509/1316; fi; U; ssr) |
| m=ua.match(/Opera[\s\/]([^\s]*)/); |
| if (m&&m[1]) { |
| o.opera=parseFloat(m[1]); |
| m=ua.match(/Opera Mini[^;]*/); |
| if (m) { |
| o.mobile = m[0]; // ex: Opera Mini/2.0.4509/1316 |
| } |
| } else { // not opera or webkit |
| m=ua.match(/MSIE\s([^;]*)/); |
| if (m&&m[1]) { |
| o.ie=parseFloat(m[1]); |
| } else { // not opera, webkit, or ie |
| m=ua.match(/Gecko\/([^\s]*)/); |
| if (m) { |
| o.gecko=1; // Gecko detected, look for revision |
| m=ua.match(/rv:([^\s\)]*)/); |
| if (m&&m[1]) { |
| o.gecko=parseFloat(m[1]); |
| } |
| } |
| } |
| } |
| } |
| } catch(e) { |
| // ignore this if we're not in a browser |
| } |
| |
| try { |
| if (typeof window=="undefined" && typeof loadClass!="undefined") { |
| o.rhino = true; |
| } |
| } catch(e) {} |
| |
| |
| return o; |
| }(); |
| |
| /** |
| * JavaScript runtime library code. |
| * @name org.antlr.runtime |
| * @namespace |
| */ |
| /** |
| * JavaScript runtime library tree parser code. |
| * @name org.antlr.runtime.tree |
| * @namespace |
| */ |
| org.antlr.namespace("org.antlr.runtime.tree"); |
| |
| /** |
| * Provides the language utilites and extensions used by the library |
| * @namespace org.antlr.lang |
| */ |
| org.antlr.lang = org.antlr.lang || /** @lends org.antlr.lang */ { |
| /** |
| * Determines whether or not the provided object is an array. |
| * Testing typeof/instanceof/constructor of arrays across frame |
| * boundaries isn't possible in Safari unless you have a reference |
| * to the other frame to test against its Array prototype. To |
| * handle this case, we test well-known array properties instead. |
| * properties. |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isArray: function(o) { |
| if (o) { |
| var l = org.antlr.lang; |
| return l.isNumber(o.length) && l.isFunction(o.splice); |
| } |
| return false; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a boolean |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isBoolean: function(o) { |
| return typeof o === 'boolean'; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a function |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isFunction: function(o) { |
| return typeof o === 'function'; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is null |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isNull: function(o) { |
| return o === null; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a legal number |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isNumber: function(o) { |
| return typeof o === 'number' && isFinite(o); |
| }, |
| |
| /** |
| * Determines whether or not the provided object is of type object |
| * or function |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isObject: function(o) { |
| return (o && (typeof o === 'object' || org.antlr.lang.isFunction(o))) || false; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is a string |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isString: function(o) { |
| return typeof o === 'string'; |
| }, |
| |
| /** |
| * Determines whether or not the provided object is undefined |
| * @param {any} o The object being testing |
| * @return {boolean} the result |
| */ |
| isUndefined: function(o) { |
| return typeof o === 'undefined'; |
| }, |
| |
| /** |
| * IE will not enumerate native functions in a derived object even if the |
| * function was overridden. This is a workaround for specific functions |
| * we care about on the Object prototype. |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @private |
| */ |
| _IEEnumFix: function(r, s) { |
| if (org.antlr.env.ua.ie) { |
| var add=["toString", "valueOf"], i; |
| for (i=0;i<add.length;i=i+1) { |
| var fname=add[i],f=s[fname]; |
| if (org.antlr.lang.isFunction(f) && f!=Object.prototype[fname]) { |
| r[fname]=f; |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Utility to set up the prototype, constructor and superclass properties to |
| * support an inheritance strategy that can chain constructors and methods. |
| * Static members will not be inherited. |
| * |
| * @method extend |
| * @static |
| * @param {Function} subc the object to modify |
| * @param {Function} superc the object to inherit |
| * @param {Object} [overrides] additional properties/methods to add to the |
| * subclass prototype. These will override the |
| * matching items obtained from the superclass |
| * if present. |
| */ |
| extend: function(subc, superc, overrides) { |
| if (!superc||!subc) { |
| throw new Error("org.antlr.lang.extend failed, please check that " + |
| "all dependencies are included."); |
| } |
| var F = function() {}; |
| F.prototype=superc.prototype; |
| subc.prototype=new F(); |
| subc.prototype.constructor=subc; |
| subc.superclass=superc.prototype; |
| if (superc.prototype.constructor == Object.prototype.constructor) { |
| superc.prototype.constructor=superc; |
| } |
| |
| if (overrides) { |
| for (var i in overrides) { |
| subc.prototype[i]=overrides[i]; |
| } |
| |
| org.antlr.lang._IEEnumFix(subc.prototype, overrides); |
| } |
| }, |
| |
| /** |
| * Applies all properties in the supplier to the receiver if the |
| * receiver does not have these properties yet. Optionally, one or |
| * more methods/properties can be specified (as additional |
| * parameters). This option will overwrite the property if receiver |
| * has it already. If true is passed as the third parameter, all |
| * properties will be applied and _will_ overwrite properties in |
| * the receiver. |
| * |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @param {Array.<String>|boolean} [arguments] zero or more properties |
| * methods to augment the receiver with. If none specified, |
| * everything in the supplier will be used unless it would |
| * overwrite an existing property in the receiver. If true |
| * is specified as the third parameter, all properties will |
| * be applied and will overwrite an existing property in |
| * the receiver |
| */ |
| augmentObject: function(r, s) { |
| if (!s||!r) { |
| throw new Error("Absorb failed, verify dependencies."); |
| } |
| var a=arguments, i, p, override=a[2]; |
| if (override && override!==true) { // only absorb the specified properties |
| for (i=2; i<a.length; i=i+1) { |
| r[a[i]] = s[a[i]]; |
| } |
| } else { // take everything, overwriting only if the third parameter is true |
| for (p in s) { |
| if (override || !r[p]) { |
| r[p] = s[p]; |
| } |
| } |
| |
| org.antlr.lang._IEEnumFix(r, s); |
| } |
| }, |
| |
| /** |
| * Same as org.antlr.lang.augmentObject, except it only applies prototype properties |
| * @see org.antlr.lang.augmentObject |
| * @param {Function} r the object to receive the augmentation |
| * @param {Function} s the object that supplies the properties to augment |
| * @param {Array.<String>|boolean} [arguments] zero or more properties methods |
| * to augment the receiver with. If none specified, everything |
| * in the supplier will be used unless it would overwrite an existing |
| * property in the receiver. if true is specified as the third |
| * parameter, all properties will be applied and will overwrite an |
| * existing property in the receiver |
| */ |
| augmentProto: function(r, s) { |
| if (!s||!r) { |
| throw new Error("Augment failed, verify dependencies."); |
| } |
| //var a=[].concat(arguments); |
| var a=[r.prototype,s.prototype]; |
| for (var i=2;i<arguments.length;i=i+1) { |
| a.push(arguments[i]); |
| } |
| org.antlr.lang.augmentObject.apply(this, a); |
| }, |
| |
| /** |
| * Returns a new object containing all of the properties of |
| * all the supplied objects. The properties from later objects |
| * will overwrite those in earlier objects. |
| * @param arguments {Object*} the objects to merge |
| * @return the new merged object |
| */ |
| merge: function() { |
| var o={}, a=arguments; |
| for (var i=0, l=a.length; i<l; i=i+1) { |
| org.antlr.lang.augmentObject(o, a[i], true); |
| } |
| return o; |
| }, |
| |
| /** |
| * A convenience method for detecting a legitimate non-null value. |
| * Returns false for null/undefined/NaN, true for other values, |
| * including 0/false/'' |
| * @param o {any} the item to test |
| * @return {boolean} true if it is not null/undefined/NaN || false |
| */ |
| isValue: function(o) { |
| var l = org.antlr.lang; |
| return (l.isObject(o) || l.isString(o) || l.isNumber(o) || l.isBoolean(o)); |
| }, |
| |
| /** @namespace org.antlr.lang.array Array convenience methods. */ |
| array: /** @lends org.antlr.lang.array */ { |
| /** |
| * Retrieve the last element of an array. Throws an error if a is not |
| * an array or empty. |
| * @param a {Array} the array stack to peek in |
| * @return the last element of the array |
| */ |
| peek: function(a) { |
| if (!org.antlr.lang.isArray(a)) { |
| throw new Error("org.antlr.lang.array.peek: a is not an array."); |
| } |
| var l = a.length; |
| if (l<=0) { |
| throw new Error("org.antlr.lang.array.peek: a is empty."); |
| } |
| return a[l-1]; |
| } |
| } |
| }; |
