The Tor Browser: comparison dom/bindings/parser/WebIDL.py

--1:000000000000
+:5dcd37b36cbe
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+""" A WebIDL parser. """
+from ply import lex, yacc
+import re
+import os
+import traceback
+import math
+# Machinery
+def parseInt(literal):
+string = literal
+sign = 0
+base = 0
+if string[0] == '-':
+sign = -1
+string = string[1:]
+else:
+sign = 1
+if string[0] == '0' and len(string) > 1:
+if string[1] == 'x' or string[1] == 'X':
+base = 16
+string = string[2:]
+else:
+base = 8
+string = string[1:]
+else:
+base = 10
+value = int(string, base)
+return value * sign
+# Magic for creating enums
+def M_add_class_attribs(attribs, start):
+def foo(name, bases, dict_):
+for v, k in enumerate(attribs):
+dict_[k] = start + v
+assert 'length' not in dict_
+dict_['length'] = start + len(attribs)
+return type(name, bases, dict_)
+return foo
+def enum(*names, **kw):
+if len(kw) == 1:
+base = kw['base'].__class__
+start = base.length
+else:
+assert len(kw) == 0
+base = object
+start = 0
+class Foo(base):
+__metaclass__ = M_add_class_attribs(names, start)
+def __setattr__(self, name, value):  # this makes it read-only
+raise NotImplementedError
+return Foo()
+class WebIDLError(Exception):
+def __init__(self, message, locations, warning=False):
+self.message = message
+self.locations = [str(loc) for loc in locations]
+self.warning = warning
+def __str__(self):
+return "%s: %s%s%s" % (self.warning and 'warning' or 'error',
+self.message,
+", " if len(self.locations) != 0 else "",
+"\n".join(self.locations))
+class Location(object):
+def __init__(self, lexer, lineno, lexpos, filename):
+self._line = None
+self._lineno = lineno
+self._lexpos = lexpos
+self._lexdata = lexer.lexdata
+self._file = filename if filename else "<unknown>"
+def __eq__(self, other):
+return self._lexpos == other._lexpos and \
+self._file == other._file
+def filename(self):
+return self._file
+def resolve(self):
+if self._line:
+return
+startofline = self._lexdata.rfind('\n', 0, self._lexpos) + 1
+endofline = self._lexdata.find('\n', self._lexpos, self._lexpos + 80)
+if endofline != -1:
+self._line = self._lexdata[startofline:endofline]
+else:
+self._line = self._lexdata[startofline:]
+self._colno = self._lexpos - startofline
+# Our line number seems to point to the start of self._lexdata
+self._lineno += self._lexdata.count('\n', 0, startofline)
+def get(self):
+self.resolve()
+return "%s line %s:%s" % (self._file, self._lineno, self._colno)
+def _pointerline(self):
+return " " * self._colno + "^"
+def __str__(self):
+self.resolve()
+return "%s line %s:%s\n%s\n%s" % (self._file, self._lineno, self._colno,
+self._line, self._pointerline())
+class BuiltinLocation(object):
+def __init__(self, text):
+self.msg = text + "\n"
+def __eq__(self, other):
+return isinstance(other, BuiltinLocation) and \
+self.msg == other.msg
+def filename(self):
+return '<builtin>'
+def resolve(self):
+pass
+def get(self):
+return self.msg
+def __str__(self):
+return self.get()
+# Data Model
+class IDLObject(object):
+def __init__(self, location):
+self.location = location
+self.userData = dict()
+def filename(self):
+return self.location.filename()
+def isInterface(self):
+return False
+def isEnum(self):
+return False
+def isCallback(self):
+return False
+def isType(self):
+return False
+def isDictionary(self):
+return False;
+def isUnion(self):
+return False
+def getUserData(self, key, default):
+return self.userData.get(key, default)
+def setUserData(self, key, value):
+self.userData[key] = value
+def addExtendedAttributes(self, attrs):
+assert False # Override me!
+def handleExtendedAttribute(self, attr):
+assert False # Override me!
+def _getDependentObjects(self):
+assert False # Override me!
+def getDeps(self, visited=None):
+""" Return a set of files that this object depends on.  If any of
+these files are changed the parser needs to be rerun to regenerate
+a new IDLObject.
+The visited argument is a set of all the objects already visited.
+We must test to see if we are in it, and if so, do nothing.  This
+prevents infinite recursion."""
+# NB: We can't use visited=set() above because the default value is
+# evaluated when the def statement is evaluated, not when the function
+# is executed, so there would be one set for all invocations.
+if visited == None:
+visited = set()
+if self in visited:
+return set()
+visited.add(self)
+deps = set()
+if self.filename() != "<builtin>":
+deps.add(self.filename())
+for d in self._getDependentObjects():
+deps = deps.union(d.getDeps(visited))
+return deps
+class IDLScope(IDLObject):
+def __init__(self, location, parentScope, identifier):
+IDLObject.__init__(self, location)
+self.parentScope = parentScope
+if identifier:
+assert isinstance(identifier, IDLIdentifier)
+self._name = identifier
+else:
+self._name = None
+self._dict = {}
+def __str__(self):
+return self.QName()
+def QName(self):
+if self._name:
+return self._name.QName() + "::"
+return "::"
+def ensureUnique(self, identifier, object):
+"""
+Ensure that there is at most one 'identifier' in scope ('self').
+Note that object can be None.  This occurs if we end up here for an
+interface type we haven't seen yet.
+"""
+assert isinstance(identifier, IDLUnresolvedIdentifier)
+assert not object or isinstance(object, IDLObjectWithIdentifier)
+assert not object or object.identifier == identifier
+if identifier.name in self._dict:
+if not object:
+return
+# ensureUnique twice with the same object is not allowed
+assert id(object) != id(self._dict[identifier.name])
+replacement = self.resolveIdentifierConflict(self, identifier,
+self._dict[identifier.name],
+object)
+self._dict[identifier.name] = replacement
+return
+assert object
+self._dict[identifier.name] = object
+def resolveIdentifierConflict(self, scope, identifier, originalObject, newObject):
+if isinstance(originalObject, IDLExternalInterface) and \
+isinstance(newObject, IDLExternalInterface) and \
+originalObject.identifier.name == newObject.identifier.name:
+return originalObject
+if (isinstance(originalObject, IDLExternalInterface) or
+isinstance(newObject, IDLExternalInterface)):
+raise WebIDLError(
+"Name collision between "
+"interface declarations for identifier '%s' at '%s' and '%s'"
+% (identifier.name,
+originalObject.location, newObject.location), [])
+# We do the merging of overloads here as opposed to in IDLInterface
+# because we need to merge overloads of NamedConstructors and we need to
+# detect conflicts in those across interfaces. See also the comment in
+# IDLInterface.addExtendedAttributes for "NamedConstructor".
+if originalObject.tag == IDLInterfaceMember.Tags.Method and \
+newObject.tag == IDLInterfaceMember.Tags.Method:
+return originalObject.addOverload(newObject)
+# Default to throwing, derived classes can override.
+conflictdesc = "\n\t%s at %s\n\t%s at %s" % \
+(originalObject, originalObject.location, newObject, newObject.location)
+raise WebIDLError(
+"Multiple unresolvable definitions of identifier '%s' in scope '%s%s"
+% (identifier.name, str(self), conflictdesc), [])
+def _lookupIdentifier(self, identifier):
+return self._dict[identifier.name]
+def lookupIdentifier(self, identifier):
+assert isinstance(identifier, IDLIdentifier)
+assert identifier.scope == self
+return self._lookupIdentifier(identifier)
+class IDLIdentifier(IDLObject):
+def __init__(self, location, scope, name):
+IDLObject.__init__(self, location)
+self.name = name
+assert isinstance(scope, IDLScope)
+self.scope = scope
+def __str__(self):
+return self.QName()
+def QName(self):
+return self.scope.QName() + self.name
+def __hash__(self):
+return self.QName().__hash__()
+def __eq__(self, other):
+return self.QName() == other.QName()
+def object(self):
+return self.scope.lookupIdentifier(self)
+class IDLUnresolvedIdentifier(IDLObject):
+def __init__(self, location, name, allowDoubleUnderscore = False,
+allowForbidden = False):
+IDLObject.__init__(self, location)
+assert len(name) > 0
+if name[:2] == "__" and name != "__content" and name != "___noSuchMethod__"  and not allowDoubleUnderscore:
+raise WebIDLError("Identifiers beginning with __ are reserved",
+[location])
+if name[0] == '_' and not allowDoubleUnderscore:
+name = name[1:]
+# TODO: Bug 872377, Restore "toJSON" to below list.
+# We sometimes need custom serialization, so allow toJSON for now.
+if (name in ["constructor", "toString"] and
+not allowForbidden):
+raise WebIDLError("Cannot use reserved identifier '%s'" % (name),
+[location])
+self.name = name
+def __str__(self):
+return self.QName()
+def QName(self):
+return "<unresolved scope>::" + self.name
+def resolve(self, scope, object):
+assert isinstance(scope, IDLScope)
+assert not object or isinstance(object, IDLObjectWithIdentifier)
+assert not object or object.identifier == self
+scope.ensureUnique(self, object)
+identifier = IDLIdentifier(self.location, scope, self.name)
+if object:
+object.identifier = identifier
+return identifier
+def finish(self):
+assert False # Should replace with a resolved identifier first.
+class IDLObjectWithIdentifier(IDLObject):
+def __init__(self, location, parentScope, identifier):
+IDLObject.__init__(self, location)
+assert isinstance(identifier, IDLUnresolvedIdentifier)
+self.identifier = identifier
+if parentScope:
+self.resolve(parentScope)
+self.treatNullAs = "Default"
+def resolve(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+assert isinstance(self.identifier, IDLUnresolvedIdentifier)
+self.identifier.resolve(parentScope, self)
+def checkForStringHandlingExtendedAttributes(self, attrs,
+isDictionaryMember=False,
+isOptional=False):
+"""
+A helper function to deal with TreatNullAs.  Returns the list
+of attrs it didn't handle itself.
+"""
+assert isinstance(self, IDLArgument) or isinstance(self, IDLAttribute)
+unhandledAttrs = list()
+for attr in attrs:
+if not attr.hasValue():
+unhandledAttrs.append(attr)
+continue
+identifier = attr.identifier()
+value = attr.value()
+if identifier == "TreatNullAs":
+if not self.type.isDOMString() or self.type.nullable():
+raise WebIDLError("[TreatNullAs] is only allowed on "
+"arguments or attributes whose type is "
+"DOMString",
+[self.location])
+if isDictionaryMember:
+raise WebIDLError("[TreatNullAs] is not allowed for "
+"dictionary members", [self.location])
+if value != 'EmptyString':
+raise WebIDLError("[TreatNullAs] must take the identifier "
+"'EmptyString', not '%s'" % value,
+[self.location])
+self.treatNullAs = value
+else:
+unhandledAttrs.append(attr)
+return unhandledAttrs
+class IDLObjectWithScope(IDLObjectWithIdentifier, IDLScope):
+def __init__(self, location, parentScope, identifier):
+assert isinstance(identifier, IDLUnresolvedIdentifier)
+IDLObjectWithIdentifier.__init__(self, location, parentScope, identifier)
+IDLScope.__init__(self, location, parentScope, self.identifier)
+class IDLIdentifierPlaceholder(IDLObjectWithIdentifier):
+def __init__(self, location, identifier):
+assert isinstance(identifier, IDLUnresolvedIdentifier)
+IDLObjectWithIdentifier.__init__(self, location, None, identifier)
+def finish(self, scope):
+try:
+scope._lookupIdentifier(self.identifier)
+except:
+raise WebIDLError("Unresolved type '%s'." % self.identifier,
+[self.location])
+obj = self.identifier.resolve(scope, None)
+return scope.lookupIdentifier(obj)
+class IDLExternalInterface(IDLObjectWithIdentifier):
+def __init__(self, location, parentScope, identifier):
+assert isinstance(identifier, IDLUnresolvedIdentifier)
+assert isinstance(parentScope, IDLScope)
+self.parent = None
+IDLObjectWithIdentifier.__init__(self, location, parentScope, identifier)
+IDLObjectWithIdentifier.resolve(self, parentScope)
+def finish(self, scope):
+pass
+def validate(self):
+pass
+def isExternal(self):
+return True
+def isInterface(self):
+return True
+def isConsequential(self):
+return False
+def addExtendedAttributes(self, attrs):
+assert len(attrs) == 0
+def resolve(self, parentScope):
+pass
+def getJSImplementation(self):
+return None
+def isJSImplemented(self):
+return False
+def getNavigatorProperty(self):
+return None
+def _getDependentObjects(self):
+return set()
+class IDLInterface(IDLObjectWithScope):
+def __init__(self, location, parentScope, name, parent, members,
+isPartial):
+assert isinstance(parentScope, IDLScope)
+assert isinstance(name, IDLUnresolvedIdentifier)
+assert not isPartial or not parent
+self.parent = None
+self._callback = False
+self._finished = False
+self.members = []
+# namedConstructors needs deterministic ordering because bindings code
+# outputs the constructs in the order that namedConstructors enumerates
+# them.
+self.namedConstructors = list()
+self.implementedInterfaces = set()
+self._consequential = False
+self._isPartial = True
+# self.interfacesBasedOnSelf is the set of interfaces that inherit from
+# self or have self as a consequential interface, including self itself.
+# Used for distinguishability checking.
+self.interfacesBasedOnSelf = set([self])
+# self.interfacesImplementingSelf is the set of interfaces that directly
+# have self as a consequential interface
+self.interfacesImplementingSelf = set()
+self._hasChildInterfaces = False
+self._isOnGlobalProtoChain = False
+# Tracking of the number of reserved slots we need for our
+# members and those of ancestor interfaces.
+self.totalMembersInSlots = 0
+# Tracking of the number of own own members we have in slots
+self._ownMembersInSlots = 0
+IDLObjectWithScope.__init__(self, location, parentScope, name)
+if not isPartial:
+self.setNonPartial(location, parent, members)
+else:
+# Just remember our members for now
+self.members = members
+def __str__(self):
+return "Interface '%s'" % self.identifier.name
+def ctor(self):
+identifier = IDLUnresolvedIdentifier(self.location, "constructor",
+allowForbidden=True)
+try:
+return self._lookupIdentifier(identifier)
+except:
+return None
+def resolveIdentifierConflict(self, scope, identifier, originalObject, newObject):
+assert isinstance(scope, IDLScope)
+assert isinstance(originalObject, IDLInterfaceMember)
+assert isinstance(newObject, IDLInterfaceMember)
+retval = IDLScope.resolveIdentifierConflict(self, scope, identifier,
+originalObject, newObject)
+# Might be a ctor, which isn't in self.members
+if newObject in self.members:
+self.members.remove(newObject)
+return retval
+def finish(self, scope):
+if self._finished:
+return
+self._finished = True
+if self._isPartial:
+raise WebIDLError("Interface %s does not have a non-partial "
+"declaration" % self.identifier.name,
+[self.location])
+assert not self.parent or isinstance(self.parent, IDLIdentifierPlaceholder)
+parent = self.parent.finish(scope) if self.parent else None
+if parent and isinstance(parent, IDLExternalInterface):
+raise WebIDLError("%s inherits from %s which does not have "
+"a definition" %
+(self.identifier.name,
+self.parent.identifier.name),
+[self.location])
+assert not parent or isinstance(parent, IDLInterface)
+self.parent = parent
+assert iter(self.members)
+if self.parent:
+self.parent.finish(scope)
+self.parent._hasChildInterfaces = True
+self.totalMembersInSlots = self.parent.totalMembersInSlots
+# Interfaces with [Global] must not have anything inherit from them
+if self.parent.getExtendedAttribute("Global"):
+# Note: This is not a self.parent.isOnGlobalProtoChain() check
+# because ancestors of a [Global] interface can have other
+# descendants.
+raise WebIDLError("[Global] interface has another interface "
+"inheriting from it",
+[self.location, self.parent.location])
+# Callbacks must not inherit from non-callbacks or inherit from
+# anything that has consequential interfaces.
+# XXXbz Can non-callbacks inherit from callbacks?  Spec issue pending.
+# XXXbz Can callbacks have consequential interfaces?  Spec issue pending
+if self.isCallback():
+if not self.parent.isCallback():
+raise WebIDLError("Callback interface %s inheriting from "
+"non-callback interface %s" %
+(self.identifier.name,
+self.parent.identifier.name),
+[self.location, self.parent.location])
+elif self.parent.isCallback():
+raise WebIDLError("Non-callback interface %s inheriting from "
+"callback interface %s" %
+(self.identifier.name,
+self.parent.identifier.name),
+[self.location, self.parent.location])
+for iface in self.implementedInterfaces:
+iface.finish(scope)
+cycleInGraph = self.findInterfaceLoopPoint(self)
+if cycleInGraph:
+raise WebIDLError("Interface %s has itself as ancestor or "
+"implemented interface" % self.identifier.name,
+[self.location, cycleInGraph.location])
+if self.isCallback():
+# "implements" should have made sure we have no
+# consequential interfaces.
+assert len(self.getConsequentialInterfaces()) == 0
+# And that we're not consequential.
+assert not self.isConsequential()
+# Now resolve() and finish() our members before importing the
+# ones from our implemented interfaces.
+# resolve() will modify self.members, so we need to iterate
+# over a copy of the member list here.
+for member in list(self.members):
+member.resolve(self)
+for member in self.members:
+member.finish(scope)
+ctor = self.ctor()
+if ctor is not None:
+ctor.finish(scope)
+for ctor in self.namedConstructors:
+ctor.finish(scope)
+# Make a copy of our member list, so things that implement us
+# can get those without all the stuff we implement ourselves
+# admixed.
+self.originalMembers = list(self.members)
+# Import everything from our consequential interfaces into
+# self.members.  Sort our consequential interfaces by name
+# just so we have a consistent order.
+for iface in sorted(self.getConsequentialInterfaces(),
+cmp=cmp,
+key=lambda x: x.identifier.name):
+# Flag the interface as being someone's consequential interface
+iface.setIsConsequentialInterfaceOf(self)
+additionalMembers = iface.originalMembers;
+for additionalMember in additionalMembers:
+for member in self.members:
+if additionalMember.identifier.name == member.identifier.name:
+raise WebIDLError(
+"Multiple definitions of %s on %s coming from 'implements' statements" %
+(member.identifier.name, self),
+[additionalMember.location, member.location])
+self.members.extend(additionalMembers)
+iface.interfacesImplementingSelf.add(self)
+for ancestor in self.getInheritedInterfaces():
+ancestor.interfacesBasedOnSelf.add(self)
+for ancestorConsequential in ancestor.getConsequentialInterfaces():
+ancestorConsequential.interfacesBasedOnSelf.add(self)
+for member in self.members:
+if (member.isAttr() and member.isUnforgeable() and
+not hasattr(member, "originatingInterface")):
+member.originatingInterface = self
+# Compute slot indices for our members before we pull in
+# unforgeable members from our parent.
+for member in self.members:
+if (member.isAttr() and
+(member.getExtendedAttribute("StoreInSlot") or
+member.getExtendedAttribute("Cached"))):
+member.slotIndex = self.totalMembersInSlots
+self.totalMembersInSlots += 1
+if member.getExtendedAttribute("StoreInSlot"):
+self._ownMembersInSlots += 1
+if self.parent:
+# Make sure we don't shadow any of the [Unforgeable] attributes on
+# our ancestor interfaces.  We don't have to worry about
+# consequential interfaces here, because those have already been
+# imported into the relevant .members lists.  And we don't have to
+# worry about anything other than our parent, because it has already
+# imported its ancestors unforgeable attributes into its member
+# list.
+for unforgeableAttr in (attr for attr in self.parent.members if
+attr.isAttr() and not attr.isStatic() and
+attr.isUnforgeable()):
+shadows = [ m for m in self.members if
+(m.isAttr() or m.isMethod()) and
+not m.isStatic() and
+m.identifier.name == unforgeableAttr.identifier.name ]
+if len(shadows) != 0:
+locs = [unforgeableAttr.location] + [ s.location for s
+in shadows ]
+raise WebIDLError("Interface %s shadows [Unforgeable] "
+"members of %s" %
+(self.identifier.name,
+ancestor.identifier.name),
+locs)
+# And now just stick it in our members, since we won't be
+# inheriting this down the proto chain.  If we really cared we
+# could try to do something where we set up the unforgeable
+# attributes of ancestor interfaces, with their corresponding
+# getters, on our interface, but that gets pretty complicated
+# and seems unnecessary.
+self.members.append(unforgeableAttr)
+# Ensure that there's at most one of each {named,indexed}
+# {getter,setter,creator,deleter}, at most one stringifier,
+# and at most one legacycaller.  Note that this last is not
+# quite per spec, but in practice no one overloads
+# legacycallers.
+specialMembersSeen = {}
+for member in self.members:
+if not member.isMethod():
+continue
+if member.isGetter():
+memberType = "getters"
+elif member.isSetter():
+memberType = "setters"
+elif member.isCreator():
+memberType = "creators"
+elif member.isDeleter():
+memberType = "deleters"
+elif member.isStringifier():
+memberType = "stringifiers"
+elif member.isJsonifier():
+memberType = "jsonifiers"
+elif member.isLegacycaller():
+memberType = "legacycallers"
+else:
+continue
+if (memberType != "stringifiers" and memberType != "legacycallers" and
+memberType != "jsonifiers"):
+if member.isNamed():
+memberType = "named " + memberType
+else:
+assert member.isIndexed()
+memberType = "indexed " + memberType
+if memberType in specialMembersSeen:
+raise WebIDLError("Multiple " + memberType + " on %s" % (self),
+[self.location,
+specialMembersSeen[memberType].location,
+member.location])
+specialMembersSeen[memberType] = member
+if self._isOnGlobalProtoChain:
+# Make sure we have no named setters, creators, or deleters
+for memberType in ["setter", "creator", "deleter"]:
+memberId = "named " + memberType + "s"
+if memberId in specialMembersSeen:
+raise WebIDLError("Interface with [Global] has a named %s" %
+memberType,
+[self.location,
+specialMembersSeen[memberId].location])
+# Make sure we're not [OverrideBuiltins]
+if self.getExtendedAttribute("OverrideBuiltins"):
+raise WebIDLError("Interface with [Global] also has "
+"[OverrideBuiltins]",
+[self.location])
+# Mark all of our ancestors as being on the global's proto chain too
+parent = self.parent
+while parent:
+# Must not inherit from an interface with [OverrideBuiltins]
+if parent.getExtendedAttribute("OverrideBuiltins"):
+raise WebIDLError("Interface with [Global] inherits from "
+"interface with [OverrideBuiltins]",
+[self.location, parent.location])
+parent._isOnGlobalProtoChain = True
+parent = parent.parent
+def validate(self):
+for member in self.members:
+member.validate()
+# Check that PutForwards refers to another attribute and that no
+# cycles exist in forwarded assignments.
+if member.isAttr():
+iface = self
+attr = member
+putForwards = attr.getExtendedAttribute("PutForwards")
+if putForwards and self.isCallback():
+raise WebIDLError("[PutForwards] used on an attribute "
+"on interface %s which is a callback "
+"interface" % self.identifier.name,
+[self.location, member.location])
+while putForwards is not None:
+forwardIface = attr.type.unroll().inner
+fowardAttr = None
+for forwardedMember in forwardIface.members:
+if (not forwardedMember.isAttr() or
+forwardedMember.identifier.name != putForwards[0]):
+continue
+if forwardedMember == member:
+raise WebIDLError("Cycle detected in forwarded "
+"assignments for attribute %s on "
+"%s" %
+(member.identifier.name, self),
+[member.location])
+fowardAttr = forwardedMember
+break
+if fowardAttr is None:
+raise WebIDLError("Attribute %s on %s forwards to "
+"missing attribute %s" %
+(attr.identifier.name, iface, putForwards),
+[attr.location])
+iface = forwardIface
+attr = fowardAttr
+putForwards = attr.getExtendedAttribute("PutForwards")
+def isInterface(self):
+return True
+def isExternal(self):
+return False
+def setIsConsequentialInterfaceOf(self, other):
+self._consequential = True
+self.interfacesBasedOnSelf.add(other)
+def isConsequential(self):
+return self._consequential
+def setCallback(self, value):
+self._callback = value
+def isCallback(self):
+return self._callback
+def isSingleOperationInterface(self):
+assert self.isCallback() or self.isJSImplemented()
+return (
+# JS-implemented things should never need the
+# this-handling weirdness of single-operation interfaces.
+not self.isJSImplemented() and
+# Not inheriting from another interface
+not self.parent and
+# No consequential interfaces
+len(self.getConsequentialInterfaces()) == 0 and
+# No attributes of any kinds
+not any(m.isAttr() for m in self.members) and
+# There is at least one regular operation, and all regular
+# operations have the same identifier
+len(set(m.identifier.name for m in self.members if
+m.isMethod() and not m.isStatic())) == 1)
+def inheritanceDepth(self):
+depth = 0
+parent = self.parent
+while parent:
+depth = depth + 1
+parent = parent.parent
+return depth
+def hasConstants(self):
+return any(m.isConst() for m in self.members)
+def hasInterfaceObject(self):
+if self.isCallback():
+return self.hasConstants()
+return not hasattr(self, "_noInterfaceObject")
+def hasInterfacePrototypeObject(self):
+return not self.isCallback() and self.getUserData('hasConcreteDescendant', False)
+def addExtendedAttributes(self, attrs):
+self._extendedAttrDict = {}
+for attr in attrs:
+identifier = attr.identifier()
+# Special cased attrs
+if identifier == "TreatNonCallableAsNull":
+raise WebIDLError("TreatNonCallableAsNull cannot be specified on interfaces",
+[attr.location, self.location])
+if identifier == "TreatNonObjectAsNull":
+raise WebIDLError("TreatNonObjectAsNull cannot be specified on interfaces",
+[attr.location, self.location])
+elif identifier == "NoInterfaceObject":
+if not attr.noArguments():
+raise WebIDLError("[NoInterfaceObject] must take no arguments",
+[attr.location])
+if self.ctor():
+raise WebIDLError("Constructor and NoInterfaceObject are incompatible",
+[self.location])
+self._noInterfaceObject = True
+elif identifier == "Constructor" or identifier == "NamedConstructor" or identifier == "ChromeConstructor":
+if identifier == "Constructor" and not self.hasInterfaceObject():
+raise WebIDLError(str(identifier) + " and NoInterfaceObject are incompatible",
+[self.location])
+if identifier == "NamedConstructor" and not attr.hasValue():
+raise WebIDLError("NamedConstructor must either take an identifier or take a named argument list",
+[attr.location])
+if identifier == "ChromeConstructor" and not self.hasInterfaceObject():
+raise WebIDLError(str(identifier) + " and NoInterfaceObject are incompatible",
+[self.location])
+args = attr.args() if attr.hasArgs() else []
+retType = IDLWrapperType(self.location, self)
+if identifier == "Constructor" or identifier == "ChromeConstructor":
+name = "constructor"
+allowForbidden = True
+else:
+name = attr.value()
+allowForbidden = False
+methodIdentifier = IDLUnresolvedIdentifier(self.location, name,
+allowForbidden=allowForbidden)
+method = IDLMethod(self.location, methodIdentifier, retType,
+args, static=True)
+# Constructors are always NewObject and are always
+# assumed to be able to throw (since there's no way to
+# indicate otherwise) and never have any other
+# extended attributes.
+method.addExtendedAttributes(
+[IDLExtendedAttribute(self.location, ("NewObject",)),
+IDLExtendedAttribute(self.location, ("Throws",))])
+if identifier == "ChromeConstructor":
+method.addExtendedAttributes(
+[IDLExtendedAttribute(self.location, ("ChromeOnly",))])
+if identifier == "Constructor" or identifier == "ChromeConstructor":
+method.resolve(self)
+else:
+# We need to detect conflicts for NamedConstructors across
+# interfaces. We first call resolve on the parentScope,
+# which will merge all NamedConstructors with the same
+# identifier accross interfaces as overloads.
+method.resolve(self.parentScope)
+# Then we look up the identifier on the parentScope. If the
+# result is the same as the method we're adding then it
+# hasn't been added as an overload and it's the first time
+# we've encountered a NamedConstructor with that identifier.
+# If the result is not the same as the method we're adding
+# then it has been added as an overload and we need to check
+# whether the result is actually one of our existing
+# NamedConstructors.
+newMethod = self.parentScope.lookupIdentifier(method.identifier)
+if newMethod == method:
+self.namedConstructors.append(method)
+elif not newMethod in self.namedConstructors:
+raise WebIDLError("NamedConstructor conflicts with a NamedConstructor of a different interface",
+[method.location, newMethod.location])
+elif (identifier == "ArrayClass"):
+if not attr.noArguments():
+raise WebIDLError("[ArrayClass] must take no arguments",
+[attr.location])
+if self.parent:
+raise WebIDLError("[ArrayClass] must not be specified on "
+"an interface with inherited interfaces",
+[attr.location, self.location])
+elif identifier == "Global":
+if not attr.noArguments():
+raise WebIDLError("[Global] must take no arguments",
+[attr.location])
+self._isOnGlobalProtoChain = True
+elif (identifier == "NeedNewResolve" or
+identifier == "OverrideBuiltins" or
+identifier == "ChromeOnly"):
+# Known extended attributes that do not take values
+if not attr.noArguments():
+raise WebIDLError("[%s] must take no arguments" % identifier,
+[attr.location])
+elif (identifier == "Pref" or
+identifier == "JSImplementation" or
+identifier == "HeaderFile" or
+identifier == "NavigatorProperty" or
+identifier == "AvailableIn" or
+identifier == "Func"):
+# Known extended attributes that take a string value
+if not attr.hasValue():
+raise WebIDLError("[%s] must have a value" % identifier,
+[attr.location])
+else:
+raise WebIDLError("Unknown extended attribute %s on interface" % identifier,
+[attr.location])
+attrlist = attr.listValue()
+self._extendedAttrDict[identifier] = attrlist if len(attrlist) else True
+def addImplementedInterface(self, implementedInterface):
+assert(isinstance(implementedInterface, IDLInterface))
+self.implementedInterfaces.add(implementedInterface)
+def getInheritedInterfaces(self):
+"""
+Returns a list of the interfaces this interface inherits from
+(not including this interface itself).  The list is in order
+from most derived to least derived.
+"""
+assert(self._finished)
+if not self.parent:
+return []
+parentInterfaces = self.parent.getInheritedInterfaces()
+parentInterfaces.insert(0, self.parent)
+return parentInterfaces
+def getConsequentialInterfaces(self):
+assert(self._finished)
+# The interfaces we implement directly
+consequentialInterfaces = set(self.implementedInterfaces)
+# And their inherited interfaces
+for iface in self.implementedInterfaces:
+consequentialInterfaces |= set(iface.getInheritedInterfaces())
+# And now collect up the consequential interfaces of all of those
+temp = set()
+for iface in consequentialInterfaces:
+temp |= iface.getConsequentialInterfaces()
+return consequentialInterfaces | temp
+def findInterfaceLoopPoint(self, otherInterface):
+"""
+Finds an interface, amongst our ancestors and consequential interfaces,
+that inherits from otherInterface or implements otherInterface
+directly.  If there is no such interface, returns None.
+"""
+if self.parent:
+if self.parent == otherInterface:
+return self
+loopPoint = self.parent.findInterfaceLoopPoint(otherInterface)
+if loopPoint:
+return loopPoint
+if otherInterface in self.implementedInterfaces:
+return self
+for iface in self.implementedInterfaces:
+loopPoint = iface.findInterfaceLoopPoint(otherInterface)
+if loopPoint:
+return loopPoint
+return None
+def getExtendedAttribute(self, name):
+return self._extendedAttrDict.get(name, None)
+def setNonPartial(self, location, parent, members):
+assert not parent or isinstance(parent, IDLIdentifierPlaceholder)
+if not self._isPartial:
+raise WebIDLError("Two non-partial definitions for the "
+"same interface",
+[location, self.location])
+self._isPartial = False
+# Now make it look like we were parsed at this new location, since
+# that's the place where the interface is "really" defined
+self.location = location
+assert not self.parent
+self.parent = parent
+# Put the new members at the beginning
+self.members = members + self.members
+def getJSImplementation(self):
+classId = self.getExtendedAttribute("JSImplementation")
+if not classId:
+return classId
+assert isinstance(classId, list)
+assert len(classId) == 1
+return classId[0]
+def isJSImplemented(self):
+return bool(self.getJSImplementation())
+def getNavigatorProperty(self):
+naviProp = self.getExtendedAttribute("NavigatorProperty")
+if not naviProp:
+return None
+assert len(naviProp) == 1
+assert isinstance(naviProp, list)
+assert len(naviProp[0]) != 0
+return naviProp[0]
+def hasChildInterfaces(self):
+return self._hasChildInterfaces
+def isOnGlobalProtoChain(self):
+return self._isOnGlobalProtoChain
+def _getDependentObjects(self):
+deps = set(self.members)
+deps.union(self.implementedInterfaces)
+if self.parent:
+deps.add(self.parent)
+return deps
+def hasMembersInSlots(self):
+return self._ownMembersInSlots != 0
+class IDLDictionary(IDLObjectWithScope):
+def __init__(self, location, parentScope, name, parent, members):
+assert isinstance(parentScope, IDLScope)
+assert isinstance(name, IDLUnresolvedIdentifier)
+assert not parent or isinstance(parent, IDLIdentifierPlaceholder)
+self.parent = parent
+self._finished = False
+self.members = list(members)
+IDLObjectWithScope.__init__(self, location, parentScope, name)
+def __str__(self):
+return "Dictionary '%s'" % self.identifier.name
+def isDictionary(self):
+return True;
+def finish(self, scope):
+if self._finished:
+return
+self._finished = True
+if self.parent:
+assert isinstance(self.parent, IDLIdentifierPlaceholder)
+oldParent = self.parent
+self.parent = self.parent.finish(scope)
+if not isinstance(self.parent, IDLDictionary):
+raise WebIDLError("Dictionary %s has parent that is not a dictionary" %
+self.identifier.name,
+[oldParent.location, self.parent.location])
+# Make sure the parent resolves all its members before we start
+# looking at them.
+self.parent.finish(scope)
+for member in self.members:
+member.resolve(self)
+if not member.isComplete():
+member.complete(scope)
+assert member.type.isComplete()
+# Members of a dictionary are sorted in lexicographic order
+self.members.sort(cmp=cmp, key=lambda x: x.identifier.name)
+inheritedMembers = []
+ancestor = self.parent
+while ancestor:
+if ancestor == self:
+raise WebIDLError("Dictionary %s has itself as an ancestor" %
+self.identifier.name,
+[self.identifier.location])
+inheritedMembers.extend(ancestor.members)
+ancestor = ancestor.parent
+# Catch name duplication
+for inheritedMember in inheritedMembers:
+for member in self.members:
+if member.identifier.name == inheritedMember.identifier.name:
+raise WebIDLError("Dictionary %s has two members with name %s" %
+(self.identifier.name, member.identifier.name),
+[member.location, inheritedMember.location])
+def validate(self):
+def typeContainsDictionary(memberType, dictionary):
+"""
+Returns a tuple whose:
+- First element is a Boolean value indicating whether
+memberType contains dictionary.
+- Second element is:
+A list of locations that leads from the type that was passed in
+the memberType argument, to the dictionary being validated,
+if the boolean value in the first element is True.
+None, if the boolean value in the first element is False.
+"""
+if (memberType.nullable() or
+memberType.isArray() or
+memberType.isSequence() or
+memberType.isMozMap()):
+return typeContainsDictionary(memberType.inner, dictionary)
+if memberType.isDictionary():
+if memberType.inner == dictionary:
+return (True, [memberType.location])
+(contains, locations) = dictionaryContainsDictionary(memberType.inner, \
+dictionary)
+if contains:
+return (True, [memberType.location] + locations)
+if memberType.isUnion():
+for member in memberType.flatMemberTypes:
+(contains, locations) = typeContainsDictionary(member, dictionary)
+if contains:
+return (True, locations)
+return (False, None)
+def dictionaryContainsDictionary(dictMember, dictionary):
+for member in dictMember.members:
+(contains, locations) = typeContainsDictionary(member.type, dictionary)
+if contains:
+return (True, [member.location] + locations)
+if dictMember.parent:
+if dictMember.parent == dictionary:
+return (True, [dictMember.location])
+else:
+(contains, locations) = dictionaryContainsDictionary(dictMember.parent, dictionary)
+if contains:
+return (True, [dictMember.location] + locations)
+return (False, None)
+for member in self.members:
+if member.type.isDictionary() and member.type.nullable():
+raise WebIDLError("Dictionary %s has member with nullable "
+"dictionary type" % self.identifier.name,
+[member.location])
+(contains, locations) = typeContainsDictionary(member.type, self)
+if contains:
+raise WebIDLError("Dictionary %s has member with itself as type." %
+self.identifier.name,
+[member.location] + locations)
+def addExtendedAttributes(self, attrs):
+assert len(attrs) == 0
+def _getDependentObjects(self):
+deps = set(self.members)
+if (self.parent):
+deps.add(self.parent)
+return deps
+class IDLEnum(IDLObjectWithIdentifier):
+def __init__(self, location, parentScope, name, values):
+assert isinstance(parentScope, IDLScope)
+assert isinstance(name, IDLUnresolvedIdentifier)
+if len(values) != len(set(values)):
+raise WebIDLError("Enum %s has multiple identical strings" % name.name,
+[location])
+IDLObjectWithIdentifier.__init__(self, location, parentScope, name)
+self._values = values
+def values(self):
+return self._values
+def finish(self, scope):
+pass
+def validate(self):
+pass
+def isEnum(self):
+return True
+def addExtendedAttributes(self, attrs):
+assert len(attrs) == 0
+def _getDependentObjects(self):
+return set()
+class IDLType(IDLObject):
+Tags = enum(
+# The integer types
+'int8',
+'uint8',
+'int16',
+'uint16',
+'int32',
+'uint32',
+'int64',
+'uint64',
+# Additional primitive types
+'bool',
+'unrestricted_float',
+'float',
+'unrestricted_double',
+# "double" last primitive type to match IDLBuiltinType
+'double',
+# Other types
+'any',
+'domstring',
+'bytestring',
+'object',
+'date',
+'void',
+# Funny stuff
+'interface',
+'dictionary',
+'enum',
+'callback',
+'union',
+'sequence',
+'mozmap',
+'array'
+)
+def __init__(self, location, name):
+IDLObject.__init__(self, location)
+self.name = name
+self.builtin = False
+def __eq__(self, other):
+return other and self.builtin == other.builtin and self.name == other.name
+def __ne__(self, other):
+return not self == other
+def __str__(self):
+return str(self.name)
+def isType(self):
+return True
+def nullable(self):
+return False
+def isPrimitive(self):
+return False
+def isBoolean(self):
+return False
+def isNumeric(self):
+return False
+def isString(self):
+return False
+def isByteString(self):
+return False
+def isDOMString(self):
+return False
+def isVoid(self):
+return self.name == "Void"
+def isSequence(self):
+return False
+def isMozMap(self):
+return False
+def isArray(self):
+return False
+def isArrayBuffer(self):
+return False
+def isArrayBufferView(self):
+return False
+def isTypedArray(self):
+return False
+def isCallbackInterface(self):
+return False
+def isNonCallbackInterface(self):
+return False
+def isGeckoInterface(self):
+""" Returns a boolean indicating whether this type is an 'interface'
+type that is implemented in Gecko. At the moment, this returns
+true for all interface types that are not types from the TypedArray
+spec."""
+return self.isInterface() and not self.isSpiderMonkeyInterface()
+def isSpiderMonkeyInterface(self):
+""" Returns a boolean indicating whether this type is an 'interface'
+type that is implemented in Spidermonkey.  At the moment, this
+only returns true for the types from the TypedArray spec. """
+return self.isInterface() and (self.isArrayBuffer() or \
+self.isArrayBufferView() or \
+self.isTypedArray())
+def isDictionary(self):
+return False
+def isInterface(self):
+return False
+def isAny(self):
+return self.tag() == IDLType.Tags.any
+def isDate(self):
+return self.tag() == IDLType.Tags.date
+def isObject(self):
+return self.tag() == IDLType.Tags.object
+def isPromise(self):
+return False
+def isComplete(self):
+return True
+def includesRestrictedFloat(self):
+return False
+def isFloat(self):
+return False
+def isUnrestricted(self):
+# Should only call this on float types
+assert self.isFloat()
+def isSerializable(self):
+return False
+def tag(self):
+assert False # Override me!
+def treatNonCallableAsNull(self):
+assert self.tag() == IDLType.Tags.callback
+return self.nullable() and self.inner._treatNonCallableAsNull
+def treatNonObjectAsNull(self):
+assert self.tag() == IDLType.Tags.callback
+return self.nullable() and self.inner._treatNonObjectAsNull
+def addExtendedAttributes(self, attrs):
+assert len(attrs) == 0
+def resolveType(self, parentScope):
+pass
+def unroll(self):
+return self
+def isDistinguishableFrom(self, other):
+raise TypeError("Can't tell whether a generic type is or is not "
+"distinguishable from other things")
+class IDLUnresolvedType(IDLType):
+"""
+Unresolved types are interface types
+"""
+def __init__(self, location, name):
+IDLType.__init__(self, location, name)
+def isComplete(self):
+return False
+def complete(self, scope):
+obj = None
+try:
+obj = scope._lookupIdentifier(self.name)
+except:
+raise WebIDLError("Unresolved type '%s'." % self.name,
+[self.location])
+assert obj
+if obj.isType():
+# obj itself might not be complete; deal with that.
+assert obj != self
+if not obj.isComplete():
+obj = obj.complete(scope)
+return obj
+name = self.name.resolve(scope, None)
+return IDLWrapperType(self.location, obj)
+def isDistinguishableFrom(self, other):
+raise TypeError("Can't tell whether an unresolved type is or is not "
+"distinguishable from other things")
+class IDLNullableType(IDLType):
+def __init__(self, location, innerType):
+assert not innerType.isVoid()
+assert not innerType == BuiltinTypes[IDLBuiltinType.Types.any]
+IDLType.__init__(self, location, innerType.name)
+self.inner = innerType
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLNullableType) and self.inner == other.inner
+def __str__(self):
+return self.inner.__str__() + "OrNull"
+def nullable(self):
+return True
+def isCallback(self):
+return self.inner.isCallback()
+def isPrimitive(self):
+return self.inner.isPrimitive()
+def isBoolean(self):
+return self.inner.isBoolean()
+def isNumeric(self):
+return self.inner.isNumeric()
+def isString(self):
+return self.inner.isString()
+def isByteString(self):
+return self.inner.isByteString()
+def isDOMString(self):
+return self.inner.isDOMString()
+def isFloat(self):
+return self.inner.isFloat()
+def isUnrestricted(self):
+return self.inner.isUnrestricted()
+def includesRestrictedFloat(self):
+return self.inner.includesRestrictedFloat()
+def isInteger(self):
+return self.inner.isInteger()
+def isVoid(self):
+return False
+def isSequence(self):
+return self.inner.isSequence()
+def isMozMap(self):
+return self.inner.isMozMap()
+def isArray(self):
+return self.inner.isArray()
+def isArrayBuffer(self):
+return self.inner.isArrayBuffer()
+def isArrayBufferView(self):
+return self.inner.isArrayBufferView()
+def isTypedArray(self):
+return self.inner.isTypedArray()
+def isDictionary(self):
+return self.inner.isDictionary()
+def isInterface(self):
+return self.inner.isInterface()
+def isCallbackInterface(self):
+return self.inner.isCallbackInterface()
+def isNonCallbackInterface(self):
+return self.inner.isNonCallbackInterface()
+def isEnum(self):
+return self.inner.isEnum()
+def isUnion(self):
+return self.inner.isUnion()
+def isSerializable(self):
+return self.inner.isSerializable()
+def tag(self):
+return self.inner.tag()
+def resolveType(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+self.inner.resolveType(parentScope)
+def isComplete(self):
+return self.inner.isComplete()
+def complete(self, scope):
+self.inner = self.inner.complete(scope)
+if self.inner.nullable():
+raise WebIDLError("The inner type of a nullable type must not be "
+"a nullable type",
+[self.location, self.inner.location])
+if self.inner.isUnion():
+if self.inner.hasNullableType:
+raise WebIDLError("The inner type of a nullable type must not "
+"be a union type that itself has a nullable "
+"type as a member type", [self.location])
+self.name = self.inner.name
+return self
+def unroll(self):
+return self.inner.unroll()
+def isDistinguishableFrom(self, other):
+if (other.nullable() or (other.isUnion() and other.hasNullableType) or
+other.isDictionary()):
+# Can't tell which type null should become
+return False
+return self.inner.isDistinguishableFrom(other)
+def _getDependentObjects(self):
+return self.inner._getDependentObjects()
+class IDLSequenceType(IDLType):
+def __init__(self, location, parameterType):
+assert not parameterType.isVoid()
+IDLType.__init__(self, location, parameterType.name)
+self.inner = parameterType
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLSequenceType) and self.inner == other.inner
+def __str__(self):
+return self.inner.__str__() + "Sequence"
+def nullable(self):
+return False
+def isPrimitive(self):
+return False;
+def isString(self):
+return False;
+def isByteString(self):
+return False
+def isDOMString(self):
+return False
+def isVoid(self):
+return False
+def isSequence(self):
+return True
+def isArray(self):
+return False
+def isDictionary(self):
+return False
+def isInterface(self):
+return False
+def isEnum(self):
+return False
+def isSerializable(self):
+return self.inner.isSerializable()
+def includesRestrictedFloat(self):
+return self.inner.includesRestrictedFloat()
+def tag(self):
+return IDLType.Tags.sequence
+def resolveType(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+self.inner.resolveType(parentScope)
+def isComplete(self):
+return self.inner.isComplete()
+def complete(self, scope):
+self.inner = self.inner.complete(scope)
+self.name = self.inner.name
+return self
+def unroll(self):
+return self.inner.unroll()
+def isDistinguishableFrom(self, other):
+if other.isUnion():
+# Just forward to the union; it'll deal
+return other.isDistinguishableFrom(self)
+return (other.isPrimitive() or other.isString() or other.isEnum() or
+other.isDate() or other.isNonCallbackInterface())
+def _getDependentObjects(self):
+return self.inner._getDependentObjects()
+class IDLMozMapType(IDLType):
+# XXXbz This is pretty similar to IDLSequenceType in various ways.
+# And maybe to IDLNullableType.  Should we have a superclass for
+# "type containing this other type"?  Bug 1015318.
+def __init__(self, location, parameterType):
+assert not parameterType.isVoid()
+IDLType.__init__(self, location, parameterType.name)
+self.inner = parameterType
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLMozMapType) and self.inner == other.inner
+def __str__(self):
+return self.inner.__str__() + "MozMap"
+def isMozMap(self):
+return True
+def includesRestrictedFloat(self):
+return self.inner.includesRestrictedFloat()
+def tag(self):
+return IDLType.Tags.mozmap
+def resolveType(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+self.inner.resolveType(parentScope)
+def isComplete(self):
+return self.inner.isComplete()
+def complete(self, scope):
+self.inner = self.inner.complete(scope)
+self.name = self.inner.name
+return self
+def unroll(self):
+# We do not unroll our inner.  Just stop at ourselves.  That
+# lets us add headers for both ourselves and our inner as
+# needed.
+return self
+def isDistinguishableFrom(self, other):
+if other.isUnion():
+# Just forward to the union; it'll deal
+return other.isDistinguishableFrom(self)
+return (other.isPrimitive() or other.isString() or other.isEnum() or
+other.isDate() or other.isNonCallbackInterface())
+def _getDependentObjects(self):
+return self.inner._getDependentObjects()
+class IDLUnionType(IDLType):
+def __init__(self, location, memberTypes):
+IDLType.__init__(self, location, "")
+self.memberTypes = memberTypes
+self.hasNullableType = False
+self.hasDictionaryType = False
+self.flatMemberTypes = None
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLUnionType) and self.memberTypes == other.memberTypes
+def isVoid(self):
+return False
+def isUnion(self):
+return True
+def isSerializable(self):
+return all(m.isSerializable() for m in self.memberTypes)
+def includesRestrictedFloat(self):
+return any(t.includesRestrictedFloat() for t in self.memberTypes)
+def tag(self):
+return IDLType.Tags.union
+def resolveType(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+for t in self.memberTypes:
+t.resolveType(parentScope)
+def isComplete(self):
+return self.flatMemberTypes is not None
+def complete(self, scope):
+def typeName(type):
+if isinstance(type, IDLNullableType):
+return typeName(type.inner) + "OrNull"
+if isinstance(type, IDLWrapperType):
+return typeName(type._identifier.object())
+if isinstance(type, IDLObjectWithIdentifier):
+return typeName(type.identifier)
+if (isinstance(type, IDLType) and
+(type.isArray() or type.isSequence() or type.isMozMap)):
+return str(type)
+return type.name
+for (i, type) in enumerate(self.memberTypes):
+if not type.isComplete():
+self.memberTypes[i] = type.complete(scope)
+self.name = "Or".join(typeName(type) for type in self.memberTypes)
+self.flatMemberTypes = list(self.memberTypes)
+i = 0
+while i < len(self.flatMemberTypes):
+if self.flatMemberTypes[i].nullable():
+if self.hasNullableType:
+raise WebIDLError("Can't have more than one nullable types in a union",
+[nullableType.location, self.flatMemberTypes[i].location])
+if self.hasDictionaryType:
+raise WebIDLError("Can't have a nullable type and a "
+"dictionary type in a union",
+[dictionaryType.location,
+self.flatMemberTypes[i].location])
+self.hasNullableType = True
+nullableType = self.flatMemberTypes[i]
+self.flatMemberTypes[i] = self.flatMemberTypes[i].inner
+continue
+if self.flatMemberTypes[i].isDictionary():
+if self.hasNullableType:
+raise WebIDLError("Can't have a nullable type and a "
+"dictionary type in a union",
+[nullableType.location,
+self.flatMemberTypes[i].location])
+self.hasDictionaryType = True
+dictionaryType = self.flatMemberTypes[i]
+elif self.flatMemberTypes[i].isUnion():
+self.flatMemberTypes[i:i + 1] = self.flatMemberTypes[i].memberTypes
+continue
+i += 1
+for (i, t) in enumerate(self.flatMemberTypes[:-1]):
+for u in self.flatMemberTypes[i + 1:]:
+if not t.isDistinguishableFrom(u):
+raise WebIDLError("Flat member types of a union should be "
+"distinguishable, " + str(t) + " is not "
+"distinguishable from " + str(u),
+[self.location, t.location, u.location])
+return self
+def isDistinguishableFrom(self, other):
+if self.hasNullableType and other.nullable():
+# Can't tell which type null should become
+return False
+if other.isUnion():
+otherTypes = other.unroll().memberTypes
+else:
+otherTypes = [other]
+# For every type in otherTypes, check that it's distinguishable from
+# every type in our types
+for u in otherTypes:
+if any(not t.isDistinguishableFrom(u) for t in self.memberTypes):
+return False
+return True
+def _getDependentObjects(self):
+return set(self.memberTypes)
+class IDLArrayType(IDLType):
+def __init__(self, location, parameterType):
+assert not parameterType.isVoid()
+if parameterType.isSequence():
+raise WebIDLError("Array type cannot parameterize over a sequence type",
+[location])
+if parameterType.isMozMap():
+raise WebIDLError("Array type cannot parameterize over a MozMap type",
+[location])
+if parameterType.isDictionary():
+raise WebIDLError("Array type cannot parameterize over a dictionary type",
+[location])
+IDLType.__init__(self, location, parameterType.name)
+self.inner = parameterType
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLArrayType) and self.inner == other.inner
+def __str__(self):
+return self.inner.__str__() + "Array"
+def nullable(self):
+return False
+def isPrimitive(self):
+return False
+def isString(self):
+return False
+def isByteString(self):
+return False
+def isDOMString(self):
+return False
+def isVoid(self):
+return False
+def isSequence(self):
+assert not self.inner.isSequence()
+return False
+def isArray(self):
+return True
+def isDictionary(self):
+assert not self.inner.isDictionary()
+return False
+def isInterface(self):
+return False
+def isEnum(self):
+return False
+def tag(self):
+return IDLType.Tags.array
+def resolveType(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+self.inner.resolveType(parentScope)
+def isComplete(self):
+return self.inner.isComplete()
+def complete(self, scope):
+self.inner = self.inner.complete(scope)
+self.name = self.inner.name
+if self.inner.isDictionary():
+raise WebIDLError("Array type must not contain "
+"dictionary as element type.",
+[self.inner.location])
+assert not self.inner.isSequence()
+return self
+def unroll(self):
+return self.inner.unroll()
+def isDistinguishableFrom(self, other):
+if other.isUnion():
+# Just forward to the union; it'll deal
+return other.isDistinguishableFrom(self)
+return (other.isPrimitive() or other.isString() or other.isEnum() or
+other.isDate() or other.isNonCallbackInterface())
+def _getDependentObjects(self):
+return self.inner._getDependentObjects()
+class IDLTypedefType(IDLType, IDLObjectWithIdentifier):
+def __init__(self, location, innerType, name):
+IDLType.__init__(self, location, innerType.name)
+identifier = IDLUnresolvedIdentifier(location, name)
+IDLObjectWithIdentifier.__init__(self, location, None, identifier)
+self.inner = innerType
+self.name = name
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLTypedefType) and self.inner == other.inner
+def __str__(self):
+return self.identifier.name
+def nullable(self):
+return self.inner.nullable()
+def isPrimitive(self):
+return self.inner.isPrimitive()
+def isBoolean(self):
+return self.inner.isBoolean()
+def isNumeric(self):
+return self.inner.isNumeric()
+def isString(self):
+return self.inner.isString()
+def isByteString(self):
+return self.inner.isByteString()
+def isDOMString(self):
+return self.inner.isDOMString()
+def isVoid(self):
+return self.inner.isVoid()
+def isSequence(self):
+return self.inner.isSequence()
+def isMozMap(self):
+return self.inner.isMozMap()
+def isArray(self):
+return self.inner.isArray()
+def isDictionary(self):
+return self.inner.isDictionary()
+def isArrayBuffer(self):
+return self.inner.isArrayBuffer()
+def isArrayBufferView(self):
+return self.inner.isArrayBufferView()
+def isTypedArray(self):
+return self.inner.isTypedArray()
+def isInterface(self):
+return self.inner.isInterface()
+def isCallbackInterface(self):
+return self.inner.isCallbackInterface()
+def isNonCallbackInterface(self):
+return self.inner.isNonCallbackInterface()
+def isComplete(self):
+return False
+def complete(self, parentScope):
+if not self.inner.isComplete():
+self.inner = self.inner.complete(parentScope)
+assert self.inner.isComplete()
+return self.inner
+def finish(self, parentScope):
+# Maybe the IDLObjectWithIdentifier for the typedef should be
+# a separate thing from the type?  If that happens, we can
+# remove some hackery around avoiding isInterface() in
+# Configuration.py.
+self.complete(parentScope)
+def validate(self):
+pass
+# Do we need a resolveType impl?  I don't think it's particularly useful....
+def tag(self):
+return self.inner.tag()
+def unroll(self):
+return self.inner.unroll()
+def isDistinguishableFrom(self, other):
+return self.inner.isDistinguishableFrom(other)
+def _getDependentObjects(self):
+return self.inner._getDependentObjects()
+class IDLWrapperType(IDLType):
+def __init__(self, location, inner):
+IDLType.__init__(self, location, inner.identifier.name)
+self.inner = inner
+self._identifier = inner.identifier
+self.builtin = False
+def __eq__(self, other):
+return isinstance(other, IDLWrapperType) and \
+self._identifier == other._identifier and \
+self.builtin == other.builtin
+def __str__(self):
+return str(self.name) + " (Wrapper)"
+def nullable(self):
+return False
+def isPrimitive(self):
+return False
+def isString(self):
+return False
+def isByteString(self):
+return False
+def isDOMString(self):
+return False
+def isVoid(self):
+return False
+def isSequence(self):
+return False
+def isArray(self):
+return False
+def isDictionary(self):
+return isinstance(self.inner, IDLDictionary)
+def isInterface(self):
+return isinstance(self.inner, IDLInterface) or \
+isinstance(self.inner, IDLExternalInterface)
+def isCallbackInterface(self):
+return self.isInterface() and self.inner.isCallback()
+def isNonCallbackInterface(self):
+return self.isInterface() and not self.inner.isCallback()
+def isEnum(self):
+return isinstance(self.inner, IDLEnum)
+def isPromise(self):
+return isinstance(self.inner, IDLInterface) and \
+self.inner.identifier.name == "Promise"
+def isSerializable(self):
+if self.isInterface():
+if self.inner.isExternal():
+return False
+return any(m.isMethod() and m.isJsonifier() for m in self.inner.members)
+elif self.isEnum():
+return True
+elif self.isDictionary():
+return all(m.type.isSerializable() for m in self.inner.members)
+else:
+raise WebIDLError("IDLWrapperType wraps type %s that we don't know if "
+"is serializable" % type(self.inner), [self.location])
+def resolveType(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+self.inner.resolve(parentScope)
+def isComplete(self):
+return True
+def tag(self):
+if self.isInterface():
+return IDLType.Tags.interface
+elif self.isEnum():
+return IDLType.Tags.enum
+elif self.isDictionary():
+return IDLType.Tags.dictionary
+else:
+assert False
+def isDistinguishableFrom(self, other):
+if other.isUnion():
+# Just forward to the union; it'll deal
+return other.isDistinguishableFrom(self)
+assert self.isInterface() or self.isEnum() or self.isDictionary()
+if self.isEnum():
+return (other.isPrimitive() or other.isInterface() or other.isObject() or
+other.isCallback() or other.isDictionary() or
+other.isSequence() or other.isMozMap() or other.isArray() or
+other.isDate())
+if self.isDictionary() and other.nullable():
+return False
+if other.isPrimitive() or other.isString() or other.isEnum() or other.isDate():
+return True
+if self.isDictionary():
+return other.isNonCallbackInterface()
+assert self.isInterface()
+if other.isInterface():
+if other.isSpiderMonkeyInterface():
+# Just let |other| handle things
+return other.isDistinguishableFrom(self)
+assert self.isGeckoInterface() and other.isGeckoInterface()
+if self.inner.isExternal() or other.unroll().inner.isExternal():
+return self != other
+return (len(self.inner.interfacesBasedOnSelf &
+other.unroll().inner.interfacesBasedOnSelf) == 0 and
+(self.isNonCallbackInterface() or
+other.isNonCallbackInterface()))
+if (other.isDictionary() or other.isCallback() or
+other.isSequence() or other.isMozMap() or other.isArray()):
+return self.isNonCallbackInterface()
+# Not much else |other| can be
+assert other.isObject()
+return False
+def _getDependentObjects(self):
+# NB: The codegen for an interface type depends on
+#  a) That the identifier is in fact an interface (as opposed to
+#     a dictionary or something else).
+#  b) The native type of the interface.
+#  If we depend on the interface object we will also depend on
+#  anything the interface depends on which is undesirable.  We
+#  considered implementing a dependency just on the interface type
+#  file, but then every modification to an interface would cause this
+#  to be regenerated which is still undesirable.  We decided not to
+#  depend on anything, reasoning that:
+#  1) Changing the concrete type of the interface requires modifying
+#     Bindings.conf, which is still a global dependency.
+#  2) Changing an interface to a dictionary (or vice versa) with the
+#     same identifier should be incredibly rare.
+return set()
+class IDLBuiltinType(IDLType):
+Types = enum(
+# The integer types
+'byte',
+'octet',
+'short',
+'unsigned_short',
+'long',
+'unsigned_long',
+'long_long',
+'unsigned_long_long',
+# Additional primitive types
+'boolean',
+'unrestricted_float',
+'float',
+'unrestricted_double',
+# IMPORTANT: "double" must be the last primitive type listed
+'double',
+# Other types
+'any',
+'domstring',
+'bytestring',
+'object',
+'date',
+'void',
+# Funny stuff
+'ArrayBuffer',
+'ArrayBufferView',
+'Int8Array',
+'Uint8Array',
+'Uint8ClampedArray',
+'Int16Array',
+'Uint16Array',
+'Int32Array',
+'Uint32Array',
+'Float32Array',
+'Float64Array'
+)
+TagLookup = {
+Types.byte: IDLType.Tags.int8,
+Types.octet: IDLType.Tags.uint8,
+Types.short: IDLType.Tags.int16,
+Types.unsigned_short: IDLType.Tags.uint16,
+Types.long: IDLType.Tags.int32,
+Types.unsigned_long: IDLType.Tags.uint32,
+Types.long_long: IDLType.Tags.int64,
+Types.unsigned_long_long: IDLType.Tags.uint64,
+Types.boolean: IDLType.Tags.bool,
+Types.unrestricted_float: IDLType.Tags.unrestricted_float,
+Types.float: IDLType.Tags.float,
+Types.unrestricted_double: IDLType.Tags.unrestricted_double,
+Types.double: IDLType.Tags.double,
+Types.any: IDLType.Tags.any,
+Types.domstring: IDLType.Tags.domstring,
+Types.bytestring: IDLType.Tags.bytestring,
+Types.object: IDLType.Tags.object,
+Types.date: IDLType.Tags.date,
+Types.void: IDLType.Tags.void,
+Types.ArrayBuffer: IDLType.Tags.interface,
+Types.ArrayBufferView: IDLType.Tags.interface,
+Types.Int8Array: IDLType.Tags.interface,
+Types.Uint8Array: IDLType.Tags.interface,
+Types.Uint8ClampedArray: IDLType.Tags.interface,
+Types.Int16Array: IDLType.Tags.interface,
+Types.Uint16Array: IDLType.Tags.interface,
+Types.Int32Array: IDLType.Tags.interface,
+Types.Uint32Array: IDLType.Tags.interface,
+Types.Float32Array: IDLType.Tags.interface,
+Types.Float64Array: IDLType.Tags.interface
+}
+def __init__(self, location, name, type):
+IDLType.__init__(self, location, name)
+self.builtin = True
+self._typeTag = type
+def isPrimitive(self):
+return self._typeTag <= IDLBuiltinType.Types.double
+def isBoolean(self):
+return self._typeTag == IDLBuiltinType.Types.boolean
+def isNumeric(self):
+return self.isPrimitive() and not self.isBoolean()
+def isString(self):
+return self._typeTag == IDLBuiltinType.Types.domstring or \
+self._typeTag == IDLBuiltinType.Types.bytestring
+def isByteString(self):
+return self._typeTag == IDLBuiltinType.Types.bytestring
+def isDOMString(self):
+return self._typeTag == IDLBuiltinType.Types.domstring
+def isInteger(self):
+return self._typeTag <= IDLBuiltinType.Types.unsigned_long_long
+def isArrayBuffer(self):
+return self._typeTag == IDLBuiltinType.Types.ArrayBuffer
+def isArrayBufferView(self):
+return self._typeTag == IDLBuiltinType.Types.ArrayBufferView
+def isTypedArray(self):
+return self._typeTag >= IDLBuiltinType.Types.Int8Array and \
+self._typeTag <= IDLBuiltinType.Types.Float64Array
+def isInterface(self):
+# TypedArray things are interface types per the TypedArray spec,
+# but we handle them as builtins because SpiderMonkey implements
+# all of it internally.
+return self.isArrayBuffer() or \
+self.isArrayBufferView() or \
+self.isTypedArray()
+def isNonCallbackInterface(self):
+# All the interfaces we can be are non-callback
+return self.isInterface()
+def isFloat(self):
+return self._typeTag == IDLBuiltinType.Types.float or \
+self._typeTag == IDLBuiltinType.Types.double or \
+self._typeTag == IDLBuiltinType.Types.unrestricted_float or \
+self._typeTag == IDLBuiltinType.Types.unrestricted_double
+def isUnrestricted(self):
+assert self.isFloat()
+return self._typeTag == IDLBuiltinType.Types.unrestricted_float or \
+self._typeTag == IDLBuiltinType.Types.unrestricted_double
+def isSerializable(self):
+return self.isPrimitive() or self.isDOMString() or self.isDate()
+def includesRestrictedFloat(self):
+return self.isFloat() and not self.isUnrestricted()
+def tag(self):
+return IDLBuiltinType.TagLookup[self._typeTag]
+def isDistinguishableFrom(self, other):
+if other.isUnion():
+# Just forward to the union; it'll deal
+return other.isDistinguishableFrom(self)
+if self.isBoolean():
+return (other.isNumeric() or other.isString() or other.isEnum() or
+other.isInterface() or other.isObject() or
+other.isCallback() or other.isDictionary() or
+other.isSequence() or other.isMozMap() or other.isArray() or
+other.isDate())
+if self.isNumeric():
+return (other.isBoolean() or other.isString() or other.isEnum() or
+other.isInterface() or other.isObject() or
+other.isCallback() or other.isDictionary() or
+other.isSequence() or other.isMozMap() or other.isArray() or
+other.isDate())
+if self.isString():
+return (other.isPrimitive() or other.isInterface() or
+other.isObject() or
+other.isCallback() or other.isDictionary() or
+other.isSequence() or other.isMozMap() or other.isArray() or
+other.isDate())
+if self.isAny():
+# Can't tell "any" apart from anything
+return False
+if self.isObject():
+return other.isPrimitive() or other.isString() or other.isEnum()
+if self.isDate():
+return (other.isPrimitive() or other.isString() or other.isEnum() or
+other.isInterface() or other.isCallback() or
+other.isDictionary() or other.isSequence() or
+other.isMozMap() or other.isArray())
+if self.isVoid():
+return not other.isVoid()
+# Not much else we could be!
+assert self.isSpiderMonkeyInterface()
+# Like interfaces, but we know we're not a callback
+return (other.isPrimitive() or other.isString() or other.isEnum() or
+other.isCallback() or other.isDictionary() or
+other.isSequence() or other.isMozMap() or other.isArray() or
+other.isDate() or
+(other.isInterface() and (
+# ArrayBuffer is distinguishable from everything
+# that's not an ArrayBuffer or a callback interface
+(self.isArrayBuffer() and not other.isArrayBuffer()) or
+# ArrayBufferView is distinguishable from everything
+# that's not an ArrayBufferView or typed array.
+(self.isArrayBufferView() and not other.isArrayBufferView() and
+not other.isTypedArray()) or
+# Typed arrays are distinguishable from everything
+# except ArrayBufferView and the same type of typed
+# array
+(self.isTypedArray() and not other.isArrayBufferView() and not
+(other.isTypedArray() and other.name == self.name)))))
+def _getDependentObjects(self):
+return set()
+BuiltinTypes = {
+IDLBuiltinType.Types.byte:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Byte",
+IDLBuiltinType.Types.byte),
+IDLBuiltinType.Types.octet:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Octet",
+IDLBuiltinType.Types.octet),
+IDLBuiltinType.Types.short:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Short",
+IDLBuiltinType.Types.short),
+IDLBuiltinType.Types.unsigned_short:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "UnsignedShort",
+IDLBuiltinType.Types.unsigned_short),
+IDLBuiltinType.Types.long:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Long",
+IDLBuiltinType.Types.long),
+IDLBuiltinType.Types.unsigned_long:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "UnsignedLong",
+IDLBuiltinType.Types.unsigned_long),
+IDLBuiltinType.Types.long_long:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "LongLong",
+IDLBuiltinType.Types.long_long),
+IDLBuiltinType.Types.unsigned_long_long:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "UnsignedLongLong",
+IDLBuiltinType.Types.unsigned_long_long),
+IDLBuiltinType.Types.boolean:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Boolean",
+IDLBuiltinType.Types.boolean),
+IDLBuiltinType.Types.float:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Float",
+IDLBuiltinType.Types.float),
+IDLBuiltinType.Types.unrestricted_float:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "UnrestrictedFloat",
+IDLBuiltinType.Types.unrestricted_float),
+IDLBuiltinType.Types.double:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Double",
+IDLBuiltinType.Types.double),
+IDLBuiltinType.Types.unrestricted_double:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "UnrestrictedDouble",
+IDLBuiltinType.Types.unrestricted_double),
+IDLBuiltinType.Types.any:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Any",
+IDLBuiltinType.Types.any),
+IDLBuiltinType.Types.domstring:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "String",
+IDLBuiltinType.Types.domstring),
+IDLBuiltinType.Types.bytestring:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "ByteString",
+IDLBuiltinType.Types.bytestring),
+IDLBuiltinType.Types.object:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Object",
+IDLBuiltinType.Types.object),
+IDLBuiltinType.Types.date:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Date",
+IDLBuiltinType.Types.date),
+IDLBuiltinType.Types.void:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Void",
+IDLBuiltinType.Types.void),
+IDLBuiltinType.Types.ArrayBuffer:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "ArrayBuffer",
+IDLBuiltinType.Types.ArrayBuffer),
+IDLBuiltinType.Types.ArrayBufferView:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "ArrayBufferView",
+IDLBuiltinType.Types.ArrayBufferView),
+IDLBuiltinType.Types.Int8Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Int8Array",
+IDLBuiltinType.Types.Int8Array),
+IDLBuiltinType.Types.Uint8Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Uint8Array",
+IDLBuiltinType.Types.Uint8Array),
+IDLBuiltinType.Types.Uint8ClampedArray:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Uint8ClampedArray",
+IDLBuiltinType.Types.Uint8ClampedArray),
+IDLBuiltinType.Types.Int16Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Int16Array",
+IDLBuiltinType.Types.Int16Array),
+IDLBuiltinType.Types.Uint16Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Uint16Array",
+IDLBuiltinType.Types.Uint16Array),
+IDLBuiltinType.Types.Int32Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Int32Array",
+IDLBuiltinType.Types.Int32Array),
+IDLBuiltinType.Types.Uint32Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Uint32Array",
+IDLBuiltinType.Types.Uint32Array),
+IDLBuiltinType.Types.Float32Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Float32Array",
+IDLBuiltinType.Types.Float32Array),
+IDLBuiltinType.Types.Float64Array:
+IDLBuiltinType(BuiltinLocation("<builtin type>"), "Float64Array",
+IDLBuiltinType.Types.Float64Array)
+}
+integerTypeSizes = {
+IDLBuiltinType.Types.byte: (-128, 127),
+IDLBuiltinType.Types.octet:  (0, 255),
+IDLBuiltinType.Types.short: (-32768, 32767),
+IDLBuiltinType.Types.unsigned_short: (0, 65535),
+IDLBuiltinType.Types.long: (-2147483648, 2147483647),
+IDLBuiltinType.Types.unsigned_long: (0, 4294967295),
+IDLBuiltinType.Types.long_long: (-9223372036854775808,
+9223372036854775807),
+IDLBuiltinType.Types.unsigned_long_long: (0, 18446744073709551615)
+}
+def matchIntegerValueToType(value):
+for type, extremes in integerTypeSizes.items():
+(min, max) = extremes
+if value <= max and value >= min:
+return BuiltinTypes[type]
+return None
+class IDLValue(IDLObject):
+def __init__(self, location, type, value):
+IDLObject.__init__(self, location)
+self.type = type
+assert isinstance(type, IDLType)
+self.value = value
+def coerceToType(self, type, location):
+if type == self.type:
+return self # Nothing to do
+# We first check for unions to ensure that even if the union is nullable
+# we end up with the right flat member type, not the union's type.
+if type.isUnion():
+# We use the flat member types here, because if we have a nullable
+# member type, or a nested union, we want the type the value
+# actually coerces to, not the nullable or nested union type.
+for subtype in type.unroll().flatMemberTypes:
+try:
+coercedValue = self.coerceToType(subtype, location)
+# Create a new IDLValue to make sure that we have the
+# correct float/double type.  This is necessary because we
+# use the value's type when it is a default value of a
+# union, and the union cares about the exact float type.
+return IDLValue(self.location, subtype, coercedValue.value)
+except:
+pass
+# If the type allows null, rerun this matching on the inner type, except
+# nullable enums.  We handle those specially, because we want our
+# default string values to stay strings even when assigned to a nullable
+# enum.
+elif type.nullable() and not type.isEnum():
+innerValue = self.coerceToType(type.inner, location)
+return IDLValue(self.location, type, innerValue.value)
+elif self.type.isInteger() and type.isInteger():
+# We're both integer types.  See if we fit.
+(min, max) = integerTypeSizes[type._typeTag]
+if self.value <= max and self.value >= min:
+# Promote
+return IDLValue(self.location, type, self.value)
+else:
+raise WebIDLError("Value %s is out of range for type %s." %
+(self.value, type), [location])
+elif self.type.isInteger() and type.isFloat():
+# Convert an integer literal into float
+if -2**24 <= self.value <= 2**24:
+floatType = BuiltinTypes[IDLBuiltinType.Types.float]
+return IDLValue(self.location, floatType, float(self.value))
+else:
+raise WebIDLError("Converting value %s to %s will lose precision." %
+(self.value, type), [location])
+elif self.type.isString() and type.isEnum():
+# Just keep our string, but make sure it's a valid value for this enum
+enum = type.unroll().inner
+if self.value not in enum.values():
+raise WebIDLError("'%s' is not a valid default value for enum %s"
+% (self.value, enum.identifier.name),
+[location, enum.location])
+return self
+elif self.type.isFloat() and type.isFloat():
+if (not type.isUnrestricted() and
+(self.value == float("inf") or self.value == float("-inf") or
+math.isnan(self.value))):
+raise WebIDLError("Trying to convert unrestricted value %s to non-unrestricted"
+% self.value, [location]);
+return self
+raise WebIDLError("Cannot coerce type %s to type %s." %
+(self.type, type), [location])
+def _getDependentObjects(self):
+return set()
+class IDLNullValue(IDLObject):
+def __init__(self, location):
+IDLObject.__init__(self, location)
+self.type = None
+self.value = None
+def coerceToType(self, type, location):
+if (not isinstance(type, IDLNullableType) and
+not (type.isUnion() and type.hasNullableType) and
+not (type.isUnion() and type.hasDictionaryType) and
+not type.isDictionary() and
+not type.isAny()):
+raise WebIDLError("Cannot coerce null value to type %s." % type,
+[location])
+nullValue = IDLNullValue(self.location)
+if type.isUnion() and not type.nullable() and type.hasDictionaryType:
+# We're actually a default value for the union's dictionary member.
+# Use its type.
+for t in type.flatMemberTypes:
+if t.isDictionary():
+nullValue.type = t
+return nullValue
+nullValue.type = type
+return nullValue
+def _getDependentObjects(self):
+return set()
+class IDLUndefinedValue(IDLObject):
+def __init__(self, location):
+IDLObject.__init__(self, location)
+self.type = None
+self.value = None
+def coerceToType(self, type, location):
+if not type.isAny():
+raise WebIDLError("Cannot coerce undefined value to type %s." % type,
+[location])
+undefinedValue = IDLUndefinedValue(self.location)
+undefinedValue.type = type
+return undefinedValue
+def _getDependentObjects(self):
+return set()
+class IDLInterfaceMember(IDLObjectWithIdentifier):
+Tags = enum(
+'Const',
+'Attr',
+'Method'
+)
+Special = enum(
+'Static',
+'Stringifier'
+)
+def __init__(self, location, identifier, tag):
+IDLObjectWithIdentifier.__init__(self, location, None, identifier)
+self.tag = tag
+self._extendedAttrDict = {}
+def isMethod(self):
+return self.tag == IDLInterfaceMember.Tags.Method
+def isAttr(self):
+return self.tag == IDLInterfaceMember.Tags.Attr
+def isConst(self):
+return self.tag == IDLInterfaceMember.Tags.Const
+def addExtendedAttributes(self, attrs):
+for attr in attrs:
+self.handleExtendedAttribute(attr)
+attrlist = attr.listValue()
+self._extendedAttrDict[attr.identifier()] = attrlist if len(attrlist) else True
+def handleExtendedAttribute(self, attr):
+pass
+def getExtendedAttribute(self, name):
+return self._extendedAttrDict.get(name, None)
+class IDLConst(IDLInterfaceMember):
+def __init__(self, location, identifier, type, value):
+IDLInterfaceMember.__init__(self, location, identifier,
+IDLInterfaceMember.Tags.Const)
+assert isinstance(type, IDLType)
+if type.isDictionary():
+raise WebIDLError("A constant cannot be of a dictionary type",
+[self.location])
+self.type = type
+self.value = value
+if identifier.name == "prototype":
+raise WebIDLError("The identifier of a constant must not be 'prototype'",
+[location])
+def __str__(self):
+return "'%s' const '%s'" % (self.type, self.identifier)
+def finish(self, scope):
+if not self.type.isComplete():
+type = self.type.complete(scope)
+if not type.isPrimitive() and not type.isString():
+locations = [self.type.location, type.location]
+try:
+locations.append(type.inner.location)
+except:
+pass
+raise WebIDLError("Incorrect type for constant", locations)
+self.type = type
+# The value might not match the type
+coercedValue = self.value.coerceToType(self.type, self.location)
+assert coercedValue
+self.value = coercedValue
+def validate(self):
+pass
+def _getDependentObjects(self):
+return set([self.type, self.value])
+class IDLAttribute(IDLInterfaceMember):
+def __init__(self, location, identifier, type, readonly, inherit=False,
+static=False, stringifier=False):
+IDLInterfaceMember.__init__(self, location, identifier,
+IDLInterfaceMember.Tags.Attr)
+assert isinstance(type, IDLType)
+self.type = type
+self.readonly = readonly
+self.inherit = inherit
+self.static = static
+self.lenientThis = False
+self._unforgeable = False
+self.stringifier = stringifier
+self.enforceRange = False
+self.clamp = False
+self.slotIndex = None
+if static and identifier.name == "prototype":
+raise WebIDLError("The identifier of a static attribute must not be 'prototype'",
+[location])
+if readonly and inherit:
+raise WebIDLError("An attribute cannot be both 'readonly' and 'inherit'",
+[self.location])
+def isStatic(self):
+return self.static
+def __str__(self):
+return "'%s' attribute '%s'" % (self.type, self.identifier)
+def finish(self, scope):
+if not self.type.isComplete():
+t = self.type.complete(scope)
+assert not isinstance(t, IDLUnresolvedType)
+assert not isinstance(t, IDLTypedefType)
+assert not isinstance(t.name, IDLUnresolvedIdentifier)
+self.type = t
+if self.type.isDictionary() and not self.getExtendedAttribute("Cached"):
+raise WebIDLError("An attribute cannot be of a dictionary type",
+[self.location])
+if self.type.isSequence() and not self.getExtendedAttribute("Cached"):
+raise WebIDLError("A non-cached attribute cannot be of a sequence "
+"type", [self.location])
+if self.type.isMozMap() and not self.getExtendedAttribute("Cached"):
+raise WebIDLError("A non-cached attribute cannot be of a MozMap "
+"type", [self.location])
+if self.type.isUnion():
+for f in self.type.unroll().flatMemberTypes:
+if f.isDictionary():
+raise WebIDLError("An attribute cannot be of a union "
+"type if one of its member types (or "
+"one of its member types's member "
+"types, and so on) is a dictionary "
+"type", [self.location, f.location])
+if f.isSequence():
+raise WebIDLError("An attribute cannot be of a union "
+"type if one of its member types (or "
+"one of its member types's member "
+"types, and so on) is a sequence "
+"type", [self.location, f.location])
+if f.isMozMap():
+raise WebIDLError("An attribute cannot be of a union "
+"type if one of its member types (or "
+"one of its member types's member "
+"types, and so on) is a MozMap "
+"type", [self.location, f.location])
+if not self.type.isInterface() and self.getExtendedAttribute("PutForwards"):
+raise WebIDLError("An attribute with [PutForwards] must have an "
+"interface type as its type", [self.location])
+if not self.type.isInterface() and self.getExtendedAttribute("SameObject"):
+raise WebIDLError("An attribute with [SameObject] must have an "
+"interface type as its type", [self.location])
+def validate(self):
+if ((self.getExtendedAttribute("Cached") or
+self.getExtendedAttribute("StoreInSlot")) and
+not self.getExtendedAttribute("Constant") and
+not self.getExtendedAttribute("Pure")):
+raise WebIDLError("Cached attributes and attributes stored in "
+"slots must be constant or pure, since the "
+"getter won't always be called.",
+[self.location])
+if self.getExtendedAttribute("Frozen"):
+if (not self.type.isSequence() and not self.type.isDictionary() and
+not self.type.isMozMap()):
+raise WebIDLError("[Frozen] is only allowed on "
+"sequence-valued, dictionary-valued, and "
+"MozMap-valued attributes",
+[self.location])
+def handleExtendedAttribute(self, attr):
+identifier = attr.identifier()
+if identifier == "SetterThrows" and self.readonly:
+raise WebIDLError("Readonly attributes must not be flagged as "
+"[SetterThrows]",
+[self.location])
+elif (((identifier == "Throws" or identifier == "GetterThrows") and
+self.getExtendedAttribute("StoreInSlot")) or
+(identifier == "StoreInSlot" and
+(self.getExtendedAttribute("Throws") or
+self.getExtendedAttribute("GetterThrows")))):
+raise WebIDLError("Throwing things can't be [Pure] or [Constant] "
+"or [SameObject] or [StoreInSlot]",
+[attr.location])
+elif identifier == "LenientThis":
+if not attr.noArguments():
+raise WebIDLError("[LenientThis] must take no arguments",
+[attr.location])
+if self.isStatic():
+raise WebIDLError("[LenientThis] is only allowed on non-static "
+"attributes", [attr.location, self.location])
+if self.getExtendedAttribute("CrossOriginReadable"):
+raise WebIDLError("[LenientThis] is not allowed in combination "
+"with [CrossOriginReadable]",
+[attr.location, self.location])
+if self.getExtendedAttribute("CrossOriginWritable"):
+raise WebIDLError("[LenientThis] is not allowed in combination "
+"with [CrossOriginWritable]",
+[attr.location, self.location])
+self.lenientThis = True
+elif identifier == "Unforgeable":
+if not self.readonly:
+raise WebIDLError("[Unforgeable] is only allowed on readonly "
+"attributes", [attr.location, self.location])
+if self.isStatic():
+raise WebIDLError("[Unforgeable] is only allowed on non-static "
+"attributes", [attr.location, self.location])
+self._unforgeable = True
+elif identifier == "SameObject" and not self.readonly:
+raise WebIDLError("[SameObject] only allowed on readonly attributes",
+[attr.location, self.location])
+elif identifier == "Constant" and not self.readonly:
+raise WebIDLError("[Constant] only allowed on readonly attributes",
+[attr.location, self.location])
+elif identifier == "PutForwards":
+if not self.readonly:
+raise WebIDLError("[PutForwards] is only allowed on readonly "
+"attributes", [attr.location, self.location])
+if self.isStatic():
+raise WebIDLError("[PutForwards] is only allowed on non-static "
+"attributes", [attr.location, self.location])
+if self.getExtendedAttribute("Replaceable") is not None:
+raise WebIDLError("[PutForwards] and [Replaceable] can't both "
+"appear on the same attribute",
+[attr.location, self.location])
+if not attr.hasValue():
+raise WebIDLError("[PutForwards] takes an identifier",
+[attr.location, self.location])
+elif identifier == "Replaceable":
+if self.getExtendedAttribute("PutForwards") is not None:
+raise WebIDLError("[PutForwards] and [Replaceable] can't both "
+"appear on the same attribute",
+[attr.location, self.location])
+elif identifier == "LenientFloat":
+if self.readonly:
+raise WebIDLError("[LenientFloat] used on a readonly attribute",
+[attr.location, self.location])
+if not self.type.includesRestrictedFloat():
+raise WebIDLError("[LenientFloat] used on an attribute with a "
+"non-restricted-float type",
+[attr.location, self.location])
+elif identifier == "EnforceRange":
+if self.readonly:
+raise WebIDLError("[EnforceRange] used on a readonly attribute",
+[attr.location, self.location])
+self.enforceRange = True
+elif identifier == "Clamp":
+if self.readonly:
+raise WebIDLError("[Clamp] used on a readonly attribute",
+[attr.location, self.location])
+self.clamp = True
+elif identifier == "StoreInSlot":
+if self.getExtendedAttribute("Cached"):
+raise WebIDLError("[StoreInSlot] and [Cached] must not be "
+"specified on the same attribute",
+[attr.location, self.location])
+elif identifier == "Cached":
+if self.getExtendedAttribute("StoreInSlot"):
+raise WebIDLError("[Cached] and [StoreInSlot] must not be "
+"specified on the same attribute",
+[attr.location, self.location])
+elif (identifier == "CrossOriginReadable" or
+identifier == "CrossOriginWritable"):
+if not attr.noArguments():
+raise WebIDLError("[%s] must take no arguments" % identifier,
+[attr.location])
+if self.isStatic():
+raise WebIDLError("[%s] is only allowed on non-static "
+"attributes" % identifier,
+[attr.location, self.location])
+if self.getExtendedAttribute("LenientThis"):
+raise WebIDLError("[LenientThis] is not allowed in combination "
+"with [%s]" % identifier,
+[attr.location, self.location])
+elif (identifier == "Pref" or
+identifier == "SetterThrows" or
+identifier == "Pure" or
+identifier == "Throws" or
+identifier == "GetterThrows" or
+identifier == "ChromeOnly" or
+identifier == "SameObject" or
+identifier == "Constant" or
+identifier == "Func" or
+identifier == "Frozen" or
+identifier == "AvailableIn" or
+identifier == "NewObject"):
+# Known attributes that we don't need to do anything with here
+pass
+else:
+raise WebIDLError("Unknown extended attribute %s on attribute" % identifier,
+[attr.location])
+IDLInterfaceMember.handleExtendedAttribute(self, attr)
+def resolve(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+self.type.resolveType(parentScope)
+IDLObjectWithIdentifier.resolve(self, parentScope)
+def addExtendedAttributes(self, attrs):
+attrs = self.checkForStringHandlingExtendedAttributes(attrs)
+IDLInterfaceMember.addExtendedAttributes(self, attrs)
+def hasLenientThis(self):
+return self.lenientThis
+def isUnforgeable(self):
+return self._unforgeable
+def _getDependentObjects(self):
+return set([self.type])
+class IDLArgument(IDLObjectWithIdentifier):
+def __init__(self, location, identifier, type, optional=False, defaultValue=None, variadic=False, dictionaryMember=False):
+IDLObjectWithIdentifier.__init__(self, location, None, identifier)
+assert isinstance(type, IDLType)
+self.type = type
+self.optional = optional
+self.defaultValue = defaultValue
+self.variadic = variadic
+self.dictionaryMember = dictionaryMember
+self._isComplete = False
+self.enforceRange = False
+self.clamp = False
+self._allowTreatNonCallableAsNull = False
+assert not variadic or optional
+def addExtendedAttributes(self, attrs):
+attrs = self.checkForStringHandlingExtendedAttributes(
+attrs,
+isDictionaryMember=self.dictionaryMember,
+isOptional=self.optional)
+for attribute in attrs:
+identifier = attribute.identifier()
+if identifier == "Clamp":
+if not attribute.noArguments():
+raise WebIDLError("[Clamp] must take no arguments",
+[attribute.location])
+if self.enforceRange:
+raise WebIDLError("[EnforceRange] and [Clamp] are mutually exclusive",
+[self.location]);
+self.clamp = True
+elif identifier == "EnforceRange":
+if not attribute.noArguments():
+raise WebIDLError("[EnforceRange] must take no arguments",
+[attribute.location])
+if self.clamp:
+raise WebIDLError("[EnforceRange] and [Clamp] are mutually exclusive",
+[self.location]);
+self.enforceRange = True
+elif identifier == "TreatNonCallableAsNull":
+self._allowTreatNonCallableAsNull = True
+else:
+raise WebIDLError("Unhandled extended attribute on an argument",
+[attribute.location])
+def isComplete(self):
+return self._isComplete
+def complete(self, scope):
+if self._isComplete:
+return
+self._isComplete = True
+if not self.type.isComplete():
+type = self.type.complete(scope)
+assert not isinstance(type, IDLUnresolvedType)
+assert not isinstance(type, IDLTypedefType)
+assert not isinstance(type.name, IDLUnresolvedIdentifier)
+self.type = type
+if ((self.type.isDictionary() or
+self.type.isUnion() and self.type.unroll().hasDictionaryType) and
+self.optional and not self.defaultValue):
+# Default optional dictionaries to null, for simplicity,
+# so the codegen doesn't have to special-case this.
+self.defaultValue = IDLNullValue(self.location)
+elif self.type.isAny():
+assert (self.defaultValue is None or
+isinstance(self.defaultValue, IDLNullValue))
+# optional 'any' values always have a default value
+if self.optional and not self.defaultValue and not self.variadic:
+# Set the default value to undefined, for simplicity, so the
+# codegen doesn't have to special-case this.
+self.defaultValue = IDLUndefinedValue(self.location)
+# Now do the coercing thing; this needs to happen after the
+# above creation of a default value.
+if self.defaultValue:
+self.defaultValue = self.defaultValue.coerceToType(self.type,
+self.location)
+assert self.defaultValue
+def allowTreatNonCallableAsNull(self):
+return self._allowTreatNonCallableAsNull
+def _getDependentObjects(self):
+deps = set([self.type])
+if self.defaultValue:
+deps.add(self.defaultValue)
+return deps
+class IDLCallbackType(IDLType, IDLObjectWithScope):
+def __init__(self, location, parentScope, identifier, returnType, arguments):
+assert isinstance(returnType, IDLType)
+IDLType.__init__(self, location, identifier.name)
+self._returnType = returnType
+# Clone the list
+self._arguments = list(arguments)
+IDLObjectWithScope.__init__(self, location, parentScope, identifier)
+for (returnType, arguments) in self.signatures():
+for argument in arguments:
+argument.resolve(self)
+self._treatNonCallableAsNull = False
+self._treatNonObjectAsNull = False
+def isCallback(self):
+return True
+def signatures(self):
+return [(self._returnType, self._arguments)]
+def tag(self):
+return IDLType.Tags.callback
+def finish(self, scope):
+if not self._returnType.isComplete():
+type = self._returnType.complete(scope)
+assert not isinstance(type, IDLUnresolvedType)
+assert not isinstance(type, IDLTypedefType)
+assert not isinstance(type.name, IDLUnresolvedIdentifier)
+self._returnType = type
+for argument in self._arguments:
+if argument.type.isComplete():
+continue
+type = argument.type.complete(scope)
+assert not isinstance(type, IDLUnresolvedType)
+assert not isinstance(type, IDLTypedefType)
+assert not isinstance(type.name, IDLUnresolvedIdentifier)
+argument.type = type
+def validate(self):
+pass
+def isDistinguishableFrom(self, other):
+if other.isUnion():
+# Just forward to the union; it'll deal
+return other.isDistinguishableFrom(self)
+return (other.isPrimitive() or other.isString() or other.isEnum() or
+other.isNonCallbackInterface() or other.isDate())
+def addExtendedAttributes(self, attrs):
+unhandledAttrs = []
+for attr in attrs:
+if attr.identifier() == "TreatNonCallableAsNull":
+self._treatNonCallableAsNull = True
+elif attr.identifier() == "TreatNonObjectAsNull":
+self._treatNonObjectAsNull = True
+else:
+unhandledAttrs.append(attr)
+if self._treatNonCallableAsNull and self._treatNonObjectAsNull:
+raise WebIDLError("Cannot specify both [TreatNonCallableAsNull] "
+"and [TreatNonObjectAsNull]", [self.location])
+if len(unhandledAttrs) != 0:
+IDLType.addExtendedAttributes(self, unhandledAttrs)
+def _getDependentObjects(self):
+return set([self._returnType] + self._arguments)
+class IDLMethodOverload:
+"""
+A class that represents a single overload of a WebIDL method.  This is not
+quite the same as an element of the "effective overload set" in the spec,
+because separate IDLMethodOverloads are not created based on arguments being
+optional.  Rather, when multiple methods have the same name, there is an
+IDLMethodOverload for each one, all hanging off an IDLMethod representing
+the full set of overloads.
+"""
+def __init__(self, returnType, arguments, location):
+self.returnType = returnType
+# Clone the list of arguments, just in case
+self.arguments = list(arguments)
+self.location = location
+def _getDependentObjects(self):
+deps = set(self.arguments)
+deps.add(self.returnType)
+return deps
+class IDLMethod(IDLInterfaceMember, IDLScope):
+Special = enum(
+'Getter',
+'Setter',
+'Creator',
+'Deleter',
+'LegacyCaller',
+base=IDLInterfaceMember.Special
+)
+TypeSuffixModifier = enum(
+'None',
+'QMark',
+'Brackets'
+)
+NamedOrIndexed = enum(
+'Neither',
+'Named',
+'Indexed'
+)
+def __init__(self, location, identifier, returnType, arguments,
+static=False, getter=False, setter=False, creator=False,
+deleter=False, specialType=NamedOrIndexed.Neither,
+legacycaller=False, stringifier=False, jsonifier=False):
+# REVIEW: specialType is NamedOrIndexed -- wow, this is messed up.
+IDLInterfaceMember.__init__(self, location, identifier,
+IDLInterfaceMember.Tags.Method)
+self._hasOverloads = False
+assert isinstance(returnType, IDLType)
+# self._overloads is a list of IDLMethodOverloads
+self._overloads = [IDLMethodOverload(returnType, arguments, location)]
+assert isinstance(static, bool)
+self._static = static
+assert isinstance(getter, bool)
+self._getter = getter
+assert isinstance(setter, bool)
+self._setter = setter
+assert isinstance(creator, bool)
+self._creator = creator
+assert isinstance(deleter, bool)
+self._deleter = deleter
+assert isinstance(legacycaller, bool)
+self._legacycaller = legacycaller
+assert isinstance(stringifier, bool)
+self._stringifier = stringifier
+assert isinstance(jsonifier, bool)
+self._jsonifier = jsonifier
+self._specialType = specialType
+if static and identifier.name == "prototype":
+raise WebIDLError("The identifier of a static operation must not be 'prototype'",
+[location])
+self.assertSignatureConstraints()
+def __str__(self):
+return "Method '%s'" % self.identifier
+def assertSignatureConstraints(self):
+if self._getter or self._deleter:
+assert len(self._overloads) == 1
+overload = self._overloads[0]
+arguments =  overload.arguments
+assert len(arguments) == 1
+assert arguments[0].type == BuiltinTypes[IDLBuiltinType.Types.domstring] or \
+arguments[0].type == BuiltinTypes[IDLBuiltinType.Types.unsigned_long]
+assert not arguments[0].optional and not arguments[0].variadic
+assert not self._getter or not overload.returnType.isVoid()
+if self._setter or self._creator:
+assert len(self._overloads) == 1
+arguments = self._overloads[0].arguments
+assert len(arguments) == 2
+assert arguments[0].type == BuiltinTypes[IDLBuiltinType.Types.domstring] or \
+arguments[0].type == BuiltinTypes[IDLBuiltinType.Types.unsigned_long]
+assert not arguments[0].optional and not arguments[0].variadic
+assert not arguments[1].optional and not arguments[1].variadic
+if self._stringifier:
+assert len(self._overloads) == 1
+overload = self._overloads[0]
+assert len(overload.arguments) == 0
+assert overload.returnType == BuiltinTypes[IDLBuiltinType.Types.domstring]
+if self._jsonifier:
+assert len(self._overloads) == 1
+overload = self._overloads[0]
+assert len(overload.arguments) == 0
+assert overload.returnType == BuiltinTypes[IDLBuiltinType.Types.object]
+def isStatic(self):
+return self._static
+def isGetter(self):
+return self._getter
+def isSetter(self):
+return self._setter
+def isCreator(self):
+return self._creator
+def isDeleter(self):
+return self._deleter
+def isNamed(self):
+assert self._specialType == IDLMethod.NamedOrIndexed.Named or \
+self._specialType == IDLMethod.NamedOrIndexed.Indexed
+return self._specialType == IDLMethod.NamedOrIndexed.Named
+def isIndexed(self):
+assert self._specialType == IDLMethod.NamedOrIndexed.Named or \
+self._specialType == IDLMethod.NamedOrIndexed.Indexed
+return self._specialType == IDLMethod.NamedOrIndexed.Indexed
+def isLegacycaller(self):
+return self._legacycaller
+def isStringifier(self):
+return self._stringifier
+def isJsonifier(self):
+return self._jsonifier
+def hasOverloads(self):
+return self._hasOverloads
+def isIdentifierLess(self):
+return self.identifier.name[:2] == "__" and self.identifier.name != "__noSuchMethod__"
+def resolve(self, parentScope):
+assert isinstance(parentScope, IDLScope)
+IDLObjectWithIdentifier.resolve(self, parentScope)
+IDLScope.__init__(self, self.location, parentScope, self.identifier)
+for (returnType, arguments) in self.signatures():
+for argument in arguments:
+argument.resolve(self)
+def addOverload(self, method):
+assert len(method._overloads) == 1
+if self._extendedAttrDict != method ._extendedAttrDict:
+raise WebIDLError("Extended attributes differ on different "
+"overloads of %s" % method.identifier,
+[self.location, method.location])
+self._overloads.extend(method._overloads)
+self._hasOverloads = True
+if self.isStatic() != method.isStatic():
+raise WebIDLError("Overloaded identifier %s appears with different values of the 'static' attribute" % method.identifier,
+[method.location])
+if self.isLegacycaller() != method.isLegacycaller():
+raise WebIDLError("Overloaded identifier %s appears with different values of the 'legacycaller' attribute" % method.identifier,
+[method.location])
+# Can't overload special things!
+assert not self.isGetter()
+assert not method.isGetter()
+assert not self.isSetter()
+assert not method.isSetter()
+assert not self.isCreator()
+assert not method.isCreator()
+assert not self.isDeleter()
+assert not method.isDeleter()
+assert not self.isStringifier()
+assert not method.isStringifier()
+assert not self.isJsonifier()
+assert not method.isJsonifier()
+return self
+def signatures(self):
+return [(overload.returnType, overload.arguments) for overload in
+self._overloads]
+def finish(self, scope):
+overloadWithPromiseReturnType = None
+overloadWithoutPromiseReturnType = None
+for overload in self._overloads:
+variadicArgument = None
+arguments = overload.arguments
+for (idx, argument) in enumerate(arguments):
+if not argument.isComplete():
+argument.complete(scope)
+assert argument.type.isComplete()
+if (argument.type.isDictionary() or
+(argument.type.isUnion() and
+argument.type.unroll().hasDictionaryType)):
+# Dictionaries and unions containing dictionaries at the
+# end of the list or followed by optional arguments must be
+# optional.
+if (not argument.optional and
+all(arg.optional for arg in arguments[idx+1:])):
+raise WebIDLError("Dictionary argument or union "
+"argument containing a dictionary "
+"not followed by a required argument "
+"must be optional",
+[argument.location])
+# An argument cannot be a Nullable Dictionary
+if argument.type.nullable():
+raise WebIDLError("An argument cannot be a nullable "
+"dictionary or nullable union "
+"containing a dictionary",
+[argument.location])
+# Only the last argument can be variadic
+if variadicArgument:
+raise WebIDLError("Variadic argument is not last argument",
+[variadicArgument.location])
+if argument.variadic:
+variadicArgument = argument
+returnType = overload.returnType
+if not returnType.isComplete():
+returnType = returnType.complete(scope)
+assert not isinstance(returnType, IDLUnresolvedType)
+assert not isinstance(returnType, IDLTypedefType)
+assert not isinstance(returnType.name, IDLUnresolvedIdentifier)
+overload.returnType = returnType
+if returnType.isPromise():
+overloadWithPromiseReturnType = overload
+else:
+overloadWithoutPromiseReturnType = overload
+# Make sure either all our overloads return Promises or none do
+if overloadWithPromiseReturnType and overloadWithoutPromiseReturnType:
+raise WebIDLError("We have overloads with both Promise and "
+"non-Promise return types",
+[overloadWithPromiseReturnType.location,
+overloadWithoutPromiseReturnType.location])
+if overloadWithPromiseReturnType and self._legacycaller:
+raise WebIDLError("May not have a Promise return type for a "
+"legacycaller.",
+[overloadWithPromiseReturnType.location])
+# Now compute various information that will be used by the
+# WebIDL overload resolution algorithm.
+self.maxArgCount = max(len(s[1]) for s in self.signatures())
+self.allowedArgCounts = [ i for i in range(self.maxArgCount+1)
+if len(self.signaturesForArgCount(i)) != 0 ]
+def validate(self):
+# Make sure our overloads are properly distinguishable and don't have
+# different argument types before the distinguishing args.
+for argCount in self.allowedArgCounts:
+possibleOverloads = self.overloadsForArgCount(argCount)
+if len(possibleOverloads) == 1:
+continue
+distinguishingIndex = self.distinguishingIndexForArgCount(argCount)
+for idx in range(distinguishingIndex):
+firstSigType = possibleOverloads[0].arguments[idx].type
+for overload in possibleOverloads[1:]:
+if overload.arguments[idx].type != firstSigType:
+raise WebIDLError(
+"Signatures for method '%s' with %d arguments have "
+"different types of arguments at index %d, which "
+"is before distinguishing index %d" %
+(self.identifier.name, argCount, idx,
+distinguishingIndex),
+[self.location, overload.location])
+def overloadsForArgCount(self, argc):
+return [overload for overload in self._overloads if
+len(overload.arguments) == argc or
+(len(overload.arguments) > argc and
+all(arg.optional for arg in overload.arguments[argc:])) or
+(len(overload.arguments) < argc and
+len(overload.arguments) > 0 and
+overload.arguments[-1].variadic)]
+def signaturesForArgCount(self, argc):
+return [(overload.returnType, overload.arguments) for overload
+in self.overloadsForArgCount(argc)]
+def locationsForArgCount(self, argc):
+return [overload.location for overload in self.overloadsForArgCount(argc)]
+def distinguishingIndexForArgCount(self, argc):
+def isValidDistinguishingIndex(idx, signatures):
+for (firstSigIndex, (firstRetval, firstArgs)) in enumerate(signatures[:-1]):
+for (secondRetval, secondArgs) in signatures[firstSigIndex+1:]:
+if idx < len(firstArgs):
+firstType = firstArgs[idx].type
+else:
+assert(firstArgs[-1].variadic)
+firstType = firstArgs[-1].type
+if idx < len(secondArgs):
+secondType = secondArgs[idx].type
+else:
+assert(secondArgs[-1].variadic)
+secondType = secondArgs[-1].type
+if not firstType.isDistinguishableFrom(secondType):
+return False
+return True
+signatures = self.signaturesForArgCount(argc)
+for idx in range(argc):
+if isValidDistinguishingIndex(idx, signatures):
+return idx
+# No valid distinguishing index.  Time to throw
+locations = self.locationsForArgCount(argc)
+raise WebIDLError("Signatures with %d arguments for method '%s' are not "
+"distinguishable" % (argc, self.identifier.name),
+locations)
+def handleExtendedAttribute(self, attr):
+identifier = attr.identifier()
+if identifier == "GetterThrows":
+raise WebIDLError("Methods must not be flagged as "
+"[GetterThrows]",
+[attr.location, self.location])
+elif identifier == "SetterThrows":
+raise WebIDLError("Methods must not be flagged as "
+"[SetterThrows]",
+[attr.location, self.location])
+elif identifier == "Unforgeable":
+raise WebIDLError("Methods must not be flagged as "
+"[Unforgeable]",
+[attr.location, self.location])
+elif identifier == "SameObject":
+raise WebIDLError("Methods must not be flagged as [SameObject]",
+[attr.location, self.location]);
+elif identifier == "Constant":
+raise WebIDLError("Methods must not be flagged as [Constant]",
+[attr.location, self.location]);
+elif identifier == "PutForwards":
+raise WebIDLError("Only attributes support [PutForwards]",
+[attr.location, self.location])
+elif identifier == "LenientFloat":
+# This is called before we've done overload resolution
+assert len(self.signatures()) == 1
+sig = self.signatures()[0]
+if not sig[0].isVoid():
+raise WebIDLError("[LenientFloat] used on a non-void method",
+[attr.location, self.location])
+if not any(arg.type.includesRestrictedFloat() for arg in sig[1]):
+raise WebIDLError("[LenientFloat] used on an operation with no "
+"restricted float type arguments",
+[attr.location, self.location])
+elif (identifier == "Throws" or
+identifier == "NewObject" or
+identifier == "ChromeOnly" or
+identifier == "Pref" or
+identifier == "Func" or
+identifier == "AvailableIn" or
+identifier == "Pure" or
+identifier == "CrossOriginCallable" or
+identifier == "WebGLHandlesContextLoss"):
+# Known attributes that we don't need to do anything with here
+pass
+else:
+raise WebIDLError("Unknown extended attribute %s on method" % identifier,
+[attr.location])
+IDLInterfaceMember.handleExtendedAttribute(self, attr)
+def returnsPromise(self):
+return self._overloads[0].returnType.isPromise()
+def _getDependentObjects(self):
+deps = set()
+for overload in self._overloads:
+deps.union(overload._getDependentObjects())
+return deps
+class IDLImplementsStatement(IDLObject):
+def __init__(self, location, implementor, implementee):
+IDLObject.__init__(self, location)
+self.implementor = implementor;
+self.implementee = implementee
+def finish(self, scope):
+assert(isinstance(self.implementor, IDLIdentifierPlaceholder))
+assert(isinstance(self.implementee, IDLIdentifierPlaceholder))
+implementor = self.implementor.finish(scope)
+implementee = self.implementee.finish(scope)
+# NOTE: we depend on not setting self.implementor and
+# self.implementee here to keep track of the original
+# locations.
+if not isinstance(implementor, IDLInterface):
+raise WebIDLError("Left-hand side of 'implements' is not an "
+"interface",
+[self.implementor.location])
+if implementor.isCallback():
+raise WebIDLError("Left-hand side of 'implements' is a callback "
+"interface",
+[self.implementor.location])
+if not isinstance(implementee, IDLInterface):
+raise WebIDLError("Right-hand side of 'implements' is not an "
+"interface",
+[self.implementee.location])
+if implementee.isCallback():
+raise WebIDLError("Right-hand side of 'implements' is a callback "
+"interface",
+[self.implementee.location])
+implementor.addImplementedInterface(implementee)
+def validate(self):
+pass
+def addExtendedAttributes(self, attrs):
+assert len(attrs) == 0
+class IDLExtendedAttribute(IDLObject):
+"""
+A class to represent IDL extended attributes so we can give them locations
+"""
+def __init__(self, location, tuple):
+IDLObject.__init__(self, location)
+self._tuple = tuple
+def identifier(self):
+return self._tuple[0]
+def noArguments(self):
+return len(self._tuple) == 1
+def hasValue(self):
+return len(self._tuple) >= 2 and isinstance(self._tuple[1], str)
+def value(self):
+assert(self.hasValue())
+return self._tuple[1]
+def hasArgs(self):
+return (len(self._tuple) == 2 and isinstance(self._tuple[1], list) or
+len(self._tuple) == 3)
+def args(self):
+assert(self.hasArgs())
+# Our args are our last element
+return self._tuple[-1]
+def listValue(self):
+"""
+Backdoor for storing random data in _extendedAttrDict
+"""
+return list(self._tuple)[1:]
+# Parser
+class Tokenizer(object):
+tokens = [
+"INTEGER",
+"FLOATLITERAL",
+"IDENTIFIER",
+"STRING",
+"WHITESPACE",
+"OTHER"
+]
+def t_FLOATLITERAL(self, t):
+r'(-?(([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([Ee][+-]?[0-9]+)?|[0-9]+[Ee][+-]?[0-9]+|Infinity))|NaN'
+t.value = float(t.value)
+return t
+def t_INTEGER(self, t):
+r'-?(0([0-7]+|[Xx][0-9A-Fa-f]+)?|[1-9][0-9]*)'
+try:
+# Can't use int(), because that doesn't handle octal properly.
+t.value = parseInt(t.value)
+except:
+raise WebIDLError("Invalid integer literal",
+[Location(lexer=self.lexer,
+lineno=self.lexer.lineno,
+lexpos=self.lexer.lexpos,
+filename=self._filename)])
+return t
+def t_IDENTIFIER(self, t):
+r'[A-Z_a-z][0-9A-Z_a-z]*'
+t.type = self.keywords.get(t.value, 'IDENTIFIER')
+return t
+def t_STRING(self, t):
+r'"[^"]*"'
+t.value = t.value[1:-1]
+return t
+def t_WHITESPACE(self, t):
+r'[\t\n\r ]+|[\t\n\r ]*((//[^\n]*|/\*.*?\*/)[\t\n\r ]*)+'
+pass
+def t_ELLIPSIS(self, t):
+r'\.\.\.'
+t.type = self.keywords.get(t.value)
+return t
+def t_OTHER(self, t):
+r'[^\t\n\r 0-9A-Z_a-z]'
+t.type = self.keywords.get(t.value, 'OTHER')
+return t
+keywords = {
+"module": "MODULE",
+"interface": "INTERFACE",
+"partial": "PARTIAL",
+"dictionary": "DICTIONARY",
+"exception": "EXCEPTION",
+"enum": "ENUM",
+"callback": "CALLBACK",
+"typedef": "TYPEDEF",
+"implements": "IMPLEMENTS",
+"const": "CONST",
+"null": "NULL",
+"true": "TRUE",
+"false": "FALSE",
+"serializer": "SERIALIZER",
+"stringifier": "STRINGIFIER",
+"jsonifier": "JSONIFIER",
+"unrestricted": "UNRESTRICTED",
+"attribute": "ATTRIBUTE",
+"readonly": "READONLY",
+"inherit": "INHERIT",
+"static": "STATIC",
+"getter": "GETTER",
+"setter": "SETTER",
+"creator": "CREATOR",
+"deleter": "DELETER",
+"legacycaller": "LEGACYCALLER",
+"optional": "OPTIONAL",
+"...": "ELLIPSIS",
+"::": "SCOPE",
+"Date": "DATE",
+"DOMString": "DOMSTRING",
+"ByteString": "BYTESTRING",
+"any": "ANY",
+"boolean": "BOOLEAN",
+"byte": "BYTE",
+"double": "DOUBLE",
+"float": "FLOAT",
+"long": "LONG",
+"object": "OBJECT",
+"octet": "OCTET",
+"optional": "OPTIONAL",
+"sequence": "SEQUENCE",
+"MozMap": "MOZMAP",
+"short": "SHORT",
+"unsigned": "UNSIGNED",
+"void": "VOID",
+":": "COLON",
+";": "SEMICOLON",
+"{": "LBRACE",
+"}": "RBRACE",
+"(": "LPAREN",
+")": "RPAREN",
+"[": "LBRACKET",
+"]": "RBRACKET",
+"?": "QUESTIONMARK",
+",": "COMMA",
+"=": "EQUALS",
+"<": "LT",
+">": "GT",
+"ArrayBuffer": "ARRAYBUFFER",
+"or": "OR"
+}
+tokens.extend(keywords.values())
+def t_error(self, t):
+raise WebIDLError("Unrecognized Input",
+[Location(lexer=self.lexer,
+lineno=self.lexer.lineno,
+lexpos=self.lexer.lexpos,
+filename = self.filename)])
+def __init__(self, outputdir, lexer=None):
+if lexer:
+self.lexer = lexer
+else:
+self.lexer = lex.lex(object=self,
+outputdir=outputdir,
+lextab='webidllex',
+reflags=re.DOTALL)
+class Parser(Tokenizer):
+def getLocation(self, p, i):
+return Location(self.lexer, p.lineno(i), p.lexpos(i), self._filename)
+def globalScope(self):
+return self._globalScope
+# The p_Foo functions here must match the WebIDL spec's grammar.
+# It's acceptable to split things at '|' boundaries.
+def p_Definitions(self, p):
+"""
+Definitions : ExtendedAttributeList Definition Definitions
+"""
+if p[2]:
+p[0] = [p[2]]
+p[2].addExtendedAttributes(p[1])
+else:
+assert not p[1]
+p[0] = []
+p[0].extend(p[3])
+def p_DefinitionsEmpty(self, p):
+"""
+Definitions :
+"""
+p[0] = []
+def p_Definition(self, p):
+"""
+Definition : CallbackOrInterface
+| PartialInterface
+| Dictionary
+| Exception
+| Enum
+| Typedef
+| ImplementsStatement
+"""
+p[0] = p[1]
+assert p[1] # We might not have implemented something ...
+def p_CallbackOrInterfaceCallback(self, p):
+"""
+CallbackOrInterface : CALLBACK CallbackRestOrInterface
+"""
+if p[2].isInterface():
+assert isinstance(p[2], IDLInterface)
+p[2].setCallback(True)
+p[0] = p[2]
+def p_CallbackOrInterfaceInterface(self, p):
+"""
+CallbackOrInterface : Interface
+"""
+p[0] = p[1]
+def p_CallbackRestOrInterface(self, p):
+"""
+CallbackRestOrInterface : CallbackRest
+| Interface
+"""
+assert p[1]
+p[0] = p[1]
+def p_Interface(self, p):
+"""
+Interface : INTERFACE IDENTIFIER Inheritance LBRACE InterfaceMembers RBRACE SEMICOLON
+"""
+location = self.getLocation(p, 1)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+members = p[5]
+parent = p[3]
+try:
+if self.globalScope()._lookupIdentifier(identifier):
+p[0] = self.globalScope()._lookupIdentifier(identifier)
+if not isinstance(p[0], IDLInterface):
+raise WebIDLError("Partial interface has the same name as "
+"non-interface object",
+[location, p[0].location])
+p[0].setNonPartial(location, parent, members)
+return
+except Exception, ex:
+if isinstance(ex, WebIDLError):
+raise ex
+pass
+p[0] = IDLInterface(location, self.globalScope(), identifier, parent,
+members, isPartial=False)
+def p_InterfaceForwardDecl(self, p):
+"""
+Interface : INTERFACE IDENTIFIER SEMICOLON
+"""
+location = self.getLocation(p, 1)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+try:
+if self.globalScope()._lookupIdentifier(identifier):
+p[0] = self.globalScope()._lookupIdentifier(identifier)
+if not isinstance(p[0], IDLExternalInterface):
+raise WebIDLError("Name collision between external "
+"interface declaration for identifier "
+"%s and %s" % (identifier.name, p[0]),
+[location, p[0].location])
+return
+except Exception, ex:
+if isinstance(ex, WebIDLError):
+raise ex
+pass
+p[0] = IDLExternalInterface(location, self.globalScope(), identifier)
+def p_PartialInterface(self, p):
+"""
+PartialInterface : PARTIAL INTERFACE IDENTIFIER LBRACE InterfaceMembers RBRACE SEMICOLON
+"""
+location = self.getLocation(p, 2)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
+members = p[5]
+try:
+if self.globalScope()._lookupIdentifier(identifier):
+p[0] = self.globalScope()._lookupIdentifier(identifier)
+if not isinstance(p[0], IDLInterface):
+raise WebIDLError("Partial interface has the same name as "
+"non-interface object",
+[location, p[0].location])
+# Just throw our members into the existing IDLInterface.  If we
+# have extended attributes, those will get added to it
+# automatically.
+p[0].members.extend(members)
+return
+except Exception, ex:
+if isinstance(ex, WebIDLError):
+raise ex
+pass
+p[0] = IDLInterface(location, self.globalScope(), identifier, None,
+members, isPartial=True)
+pass
+def p_Inheritance(self, p):
+"""
+Inheritance : COLON ScopedName
+"""
+p[0] = IDLIdentifierPlaceholder(self.getLocation(p, 2), p[2])
+def p_InheritanceEmpty(self, p):
+"""
+Inheritance :
+"""
+pass
+def p_InterfaceMembers(self, p):
+"""
+InterfaceMembers : ExtendedAttributeList InterfaceMember InterfaceMembers
+"""
+p[0] = [p[2]] if p[2] else []
+assert not p[1] or p[2]
+p[2].addExtendedAttributes(p[1])
+p[0].extend(p[3])
+def p_InterfaceMembersEmpty(self, p):
+"""
+InterfaceMembers :
+"""
+p[0] = []
+def p_InterfaceMember(self, p):
+"""
+InterfaceMember : Const
+| AttributeOrOperation
+"""
+p[0] = p[1]
+def p_Dictionary(self, p):
+"""
+Dictionary : DICTIONARY IDENTIFIER Inheritance LBRACE DictionaryMembers RBRACE SEMICOLON
+"""
+location = self.getLocation(p, 1)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+members = p[5]
+p[0] = IDLDictionary(location, self.globalScope(), identifier, p[3], members)
+def p_DictionaryMembers(self, p):
+"""
+DictionaryMembers : ExtendedAttributeList DictionaryMember DictionaryMembers
+|
+"""
+if len(p) == 1:
+# We're at the end of the list
+p[0] = []
+return
+# Add our extended attributes
+p[2].addExtendedAttributes(p[1])
+p[0] = [p[2]]
+p[0].extend(p[3])
+def p_DictionaryMember(self, p):
+"""
+DictionaryMember : Type IDENTIFIER DefaultValue SEMICOLON
+"""
+# These quack a lot like optional arguments, so just treat them that way.
+t = p[1]
+assert isinstance(t, IDLType)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+defaultValue = p[3]
+p[0] = IDLArgument(self.getLocation(p, 2), identifier, t, optional=True,
+defaultValue=defaultValue, variadic=False,
+dictionaryMember=True)
+def p_DefaultValue(self, p):
+"""
+DefaultValue : EQUALS ConstValue
+|
+"""
+if len(p) > 1:
+p[0] = p[2]
+else:
+p[0] = None
+def p_Exception(self, p):
+"""
+Exception : EXCEPTION IDENTIFIER Inheritance LBRACE ExceptionMembers RBRACE SEMICOLON
+"""
+pass
+def p_Enum(self, p):
+"""
+Enum : ENUM IDENTIFIER LBRACE EnumValueList RBRACE SEMICOLON
+"""
+location = self.getLocation(p, 1)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+values = p[4]
+assert values
+p[0] = IDLEnum(location, self.globalScope(), identifier, values)
+def p_EnumValueList(self, p):
+"""
+EnumValueList : STRING EnumValueListComma
+"""
+p[0] = [p[1]]
+p[0].extend(p[2])
+def p_EnumValueListComma(self, p):
+"""
+EnumValueListComma : COMMA EnumValueListString
+"""
+p[0] = p[2]
+def p_EnumValueListCommaEmpty(self, p):
+"""
+EnumValueListComma :
+"""
+p[0] = []
+def p_EnumValueListString(self, p):
+"""
+EnumValueListString : STRING EnumValueListComma
+"""
+p[0] = [p[1]]
+p[0].extend(p[2])
+def p_EnumValueListStringEmpty(self, p):
+"""
+EnumValueListString :
+"""
+p[0] = []
+def p_CallbackRest(self, p):
+"""
+CallbackRest : IDENTIFIER EQUALS ReturnType LPAREN ArgumentList RPAREN SEMICOLON
+"""
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 1), p[1])
+p[0] = IDLCallbackType(self.getLocation(p, 1), self.globalScope(),
+identifier, p[3], p[5])
+def p_ExceptionMembers(self, p):
+"""
+ExceptionMembers : ExtendedAttributeList ExceptionMember ExceptionMembers
+|
+"""
+pass
+def p_Typedef(self, p):
+"""
+Typedef : TYPEDEF Type IDENTIFIER SEMICOLON
+"""
+typedef = IDLTypedefType(self.getLocation(p, 1), p[2], p[3])
+typedef.resolve(self.globalScope())
+p[0] = typedef
+def p_ImplementsStatement(self, p):
+"""
+ImplementsStatement : ScopedName IMPLEMENTS ScopedName SEMICOLON
+"""
+assert(p[2] == "implements")
+implementor = IDLIdentifierPlaceholder(self.getLocation(p, 1), p[1])
+implementee = IDLIdentifierPlaceholder(self.getLocation(p, 3), p[3])
+p[0] = IDLImplementsStatement(self.getLocation(p, 1), implementor,
+implementee)
+def p_Const(self, p):
+"""
+Const : CONST ConstType IDENTIFIER EQUALS ConstValue SEMICOLON
+"""
+location = self.getLocation(p, 1)
+type = p[2]
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
+value = p[5]
+p[0] = IDLConst(location, identifier, type, value)
+def p_ConstValueBoolean(self, p):
+"""
+ConstValue : BooleanLiteral
+"""
+location = self.getLocation(p, 1)
+booleanType = BuiltinTypes[IDLBuiltinType.Types.boolean]
+p[0] = IDLValue(location, booleanType, p[1])
+def p_ConstValueInteger(self, p):
+"""
+ConstValue : INTEGER
+"""
+location = self.getLocation(p, 1)
+# We don't know ahead of time what type the integer literal is.
+# Determine the smallest type it could possibly fit in and use that.
+integerType = matchIntegerValueToType(p[1])
+if integerType == None:
+raise WebIDLError("Integer literal out of range", [location])
+p[0] = IDLValue(location, integerType, p[1])
+def p_ConstValueFloat(self, p):
+"""
+ConstValue : FLOATLITERAL
+"""
+location = self.getLocation(p, 1)
+p[0] = IDLValue(location, BuiltinTypes[IDLBuiltinType.Types.unrestricted_float], p[1])
+def p_ConstValueString(self, p):
+"""
+ConstValue : STRING
+"""
+location = self.getLocation(p, 1)
+stringType = BuiltinTypes[IDLBuiltinType.Types.domstring]
+p[0] = IDLValue(location, stringType, p[1])
+def p_ConstValueNull(self, p):
+"""
+ConstValue : NULL
+"""
+p[0] = IDLNullValue(self.getLocation(p, 1))
+def p_BooleanLiteralTrue(self, p):
+"""
+BooleanLiteral : TRUE
+"""
+p[0] = True
+def p_BooleanLiteralFalse(self, p):
+"""
+BooleanLiteral : FALSE
+"""
+p[0] = False
+def p_AttributeOrOperation(self, p):
+"""
+AttributeOrOperation : Attribute
+| Operation
+"""
+p[0] = p[1]
+def p_AttributeWithQualifier(self, p):
+"""
+Attribute : Qualifier AttributeRest
+"""
+static = IDLInterfaceMember.Special.Static in p[1]
+stringifier = IDLInterfaceMember.Special.Stringifier in p[1]
+(location, identifier, type, readonly) = p[2]
+p[0] = IDLAttribute(location, identifier, type, readonly, static=static,
+stringifier=stringifier)
+def p_Attribute(self, p):
+"""
+Attribute : Inherit AttributeRest
+"""
+(location, identifier, type, readonly) = p[2]
+p[0] = IDLAttribute(location, identifier, type, readonly, inherit=p[1])
+def p_AttributeRest(self, p):
+"""
+AttributeRest : ReadOnly ATTRIBUTE Type IDENTIFIER SEMICOLON
+"""
+location = self.getLocation(p, 2)
+readonly = p[1]
+t = p[3]
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 4), p[4])
+p[0] = (location, identifier, t, readonly)
+def p_ReadOnly(self, p):
+"""
+ReadOnly : READONLY
+"""
+p[0] = True
+def p_ReadOnlyEmpty(self, p):
+"""
+ReadOnly :
+"""
+p[0] = False
+def p_Inherit(self, p):
+"""
+Inherit : INHERIT
+"""
+p[0] = True
+def p_InheritEmpty(self, p):
+"""
+Inherit :
+"""
+p[0] = False
+def p_Operation(self, p):
+"""
+Operation : Qualifiers OperationRest
+"""
+qualifiers = p[1]
+# Disallow duplicates in the qualifier set
+if not len(set(qualifiers)) == len(qualifiers):
+raise WebIDLError("Duplicate qualifiers are not allowed",
+[self.getLocation(p, 1)])
+static = IDLInterfaceMember.Special.Static in p[1]
+# If static is there that's all that's allowed.  This is disallowed
+# by the parser, so we can assert here.
+assert not static or len(qualifiers) == 1
+stringifier = IDLInterfaceMember.Special.Stringifier in p[1]
+# If stringifier is there that's all that's allowed.  This is disallowed
+# by the parser, so we can assert here.
+assert not stringifier or len(qualifiers) == 1
+getter = True if IDLMethod.Special.Getter in p[1] else False
+setter = True if IDLMethod.Special.Setter in p[1] else False
+creator = True if IDLMethod.Special.Creator in p[1] else False
+deleter = True if IDLMethod.Special.Deleter in p[1] else False
+legacycaller = True if IDLMethod.Special.LegacyCaller in p[1] else False
+if getter or deleter:
+if setter or creator:
+raise WebIDLError("getter and deleter are incompatible with setter and creator",
+[self.getLocation(p, 1)])
+(returnType, identifier, arguments) = p[2]
+assert isinstance(returnType, IDLType)
+specialType = IDLMethod.NamedOrIndexed.Neither
+if getter or deleter:
+if len(arguments) != 1:
+raise WebIDLError("%s has wrong number of arguments" %
+("getter" if getter else "deleter"),
+[self.getLocation(p, 2)])
+argType = arguments[0].type
+if argType == BuiltinTypes[IDLBuiltinType.Types.domstring]:
+specialType = IDLMethod.NamedOrIndexed.Named
+elif argType == BuiltinTypes[IDLBuiltinType.Types.unsigned_long]:
+specialType = IDLMethod.NamedOrIndexed.Indexed
+else:
+raise WebIDLError("%s has wrong argument type (must be DOMString or UnsignedLong)" %
+("getter" if getter else "deleter"),
+[arguments[0].location])
+if arguments[0].optional or arguments[0].variadic:
+raise WebIDLError("%s cannot have %s argument" %
+("getter" if getter else "deleter",
+"optional" if arguments[0].optional else "variadic"),
+[arguments[0].location])
+if getter:
+if returnType.isVoid():
+raise WebIDLError("getter cannot have void return type",
+[self.getLocation(p, 2)])
+if setter or creator:
+if len(arguments) != 2:
+raise WebIDLError("%s has wrong number of arguments" %
+("setter" if setter else "creator"),
+[self.getLocation(p, 2)])
+argType = arguments[0].type
+if argType == BuiltinTypes[IDLBuiltinType.Types.domstring]:
+specialType = IDLMethod.NamedOrIndexed.Named
+elif argType == BuiltinTypes[IDLBuiltinType.Types.unsigned_long]:
+specialType = IDLMethod.NamedOrIndexed.Indexed
+else:
+raise WebIDLError("%s has wrong argument type (must be DOMString or UnsignedLong)" %
+("setter" if setter else "creator"),
+[arguments[0].location])
+if arguments[0].optional or arguments[0].variadic:
+raise WebIDLError("%s cannot have %s argument" %
+("setter" if setter else "creator",
+"optional" if arguments[0].optional else "variadic"),
+[arguments[0].location])
+if arguments[1].optional or arguments[1].variadic:
+raise WebIDLError("%s cannot have %s argument" %
+("setter" if setter else "creator",
+"optional" if arguments[1].optional else "variadic"),
+[arguments[1].location])
+if stringifier:
+if len(arguments) != 0:
+raise WebIDLError("stringifier has wrong number of arguments",
+[self.getLocation(p, 2)])
+if not returnType.isDOMString():
+raise WebIDLError("stringifier must have DOMString return type",
+[self.getLocation(p, 2)])
+# identifier might be None.  This is only permitted for special methods.
+if not identifier:
+if not getter and not setter and not creator and \
+not deleter and not legacycaller and not stringifier:
+raise WebIDLError("Identifier required for non-special methods",
+[self.getLocation(p, 2)])
+location = BuiltinLocation("<auto-generated-identifier>")
+identifier = IDLUnresolvedIdentifier(location, "__%s%s%s%s%s%s%s" %
+("named" if specialType == IDLMethod.NamedOrIndexed.Named else \
+"indexed" if specialType == IDLMethod.NamedOrIndexed.Indexed else "",
+"getter" if getter else "",
+"setter" if setter else "",
+"deleter" if deleter else "",
+"creator" if creator else "",
+"legacycaller" if legacycaller else "",
+"stringifier" if stringifier else ""), allowDoubleUnderscore=True)
+method = IDLMethod(self.getLocation(p, 2), identifier, returnType, arguments,
+static=static, getter=getter, setter=setter, creator=creator,
+deleter=deleter, specialType=specialType,
+legacycaller=legacycaller, stringifier=stringifier)
+p[0] = method
+def p_Stringifier(self, p):
+"""
+Operation : STRINGIFIER SEMICOLON
+"""
+identifier = IDLUnresolvedIdentifier(BuiltinLocation("<auto-generated-identifier>"),
+"__stringifier",
+allowDoubleUnderscore=True)
+method = IDLMethod(self.getLocation(p, 1),
+identifier,
+returnType=BuiltinTypes[IDLBuiltinType.Types.domstring],
+arguments=[],
+stringifier=True)
+p[0] = method
+def p_Jsonifier(self, p):
+"""
+Operation : JSONIFIER SEMICOLON
+"""
+identifier = IDLUnresolvedIdentifier(BuiltinLocation("<auto-generated-identifier>"),
+"__jsonifier", allowDoubleUnderscore=True)
+method = IDLMethod(self.getLocation(p, 1),
+identifier,
+returnType=BuiltinTypes[IDLBuiltinType.Types.object],
+arguments=[],
+jsonifier=True)
+p[0] = method
+def p_QualifierStatic(self, p):
+"""
+Qualifier : STATIC
+"""
+p[0] = [IDLInterfaceMember.Special.Static]
+def p_QualifierStringifier(self, p):
+"""
+Qualifier : STRINGIFIER
+"""
+p[0] = [IDLInterfaceMember.Special.Stringifier]
+def p_Qualifiers(self, p):
+"""
+Qualifiers : Qualifier
+| Specials
+"""
+p[0] = p[1]
+def p_Specials(self, p):
+"""
+Specials : Special Specials
+"""
+p[0] = [p[1]]
+p[0].extend(p[2])
+def p_SpecialsEmpty(self, p):
+"""
+Specials :
+"""
+p[0] = []
+def p_SpecialGetter(self, p):
+"""
+Special : GETTER
+"""
+p[0] = IDLMethod.Special.Getter
+def p_SpecialSetter(self, p):
+"""
+Special : SETTER
+"""
+p[0] = IDLMethod.Special.Setter
+def p_SpecialCreator(self, p):
+"""
+Special : CREATOR
+"""
+p[0] = IDLMethod.Special.Creator
+def p_SpecialDeleter(self, p):
+"""
+Special : DELETER
+"""
+p[0] = IDLMethod.Special.Deleter
+def p_SpecialLegacyCaller(self, p):
+"""
+Special : LEGACYCALLER
+"""
+p[0] = IDLMethod.Special.LegacyCaller
+def p_OperationRest(self, p):
+"""
+OperationRest : ReturnType OptionalIdentifier LPAREN ArgumentList RPAREN SEMICOLON
+"""
+p[0] = (p[1], p[2], p[4])
+def p_OptionalIdentifier(self, p):
+"""
+OptionalIdentifier : IDENTIFIER
+"""
+p[0] = IDLUnresolvedIdentifier(self.getLocation(p, 1), p[1])
+def p_OptionalIdentifierEmpty(self, p):
+"""
+OptionalIdentifier :
+"""
+pass
+def p_ArgumentList(self, p):
+"""
+ArgumentList : Argument Arguments
+"""
+p[0] = [p[1]] if p[1] else []
+p[0].extend(p[2])
+def p_ArgumentListEmpty(self, p):
+"""
+ArgumentList :
+"""
+p[0] = []
+def p_Arguments(self, p):
+"""
+Arguments : COMMA Argument Arguments
+"""
+p[0] = [p[2]] if p[2] else []
+p[0].extend(p[3])
+def p_ArgumentsEmpty(self, p):
+"""
+Arguments :
+"""
+p[0] = []
+def p_Argument(self, p):
+"""
+Argument : ExtendedAttributeList Optional Type Ellipsis ArgumentName DefaultValue
+"""
+t = p[3]
+assert isinstance(t, IDLType)
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 5), p[5])
+optional = p[2]
+variadic = p[4]
+defaultValue = p[6]
+if not optional and defaultValue:
+raise WebIDLError("Mandatory arguments can't have a default value.",
+[self.getLocation(p, 6)])
+# We can't test t.isAny() here and give it a default value as needed,
+# since at this point t is not a fully resolved type yet (e.g. it might
+# be a typedef).  We'll handle the 'any' case in IDLArgument.complete.
+if variadic:
+if optional:
+raise WebIDLError("Variadic arguments should not be marked optional.",
+[self.getLocation(p, 2)])
+optional = variadic
+p[0] = IDLArgument(self.getLocation(p, 5), identifier, t, optional, defaultValue, variadic)
+p[0].addExtendedAttributes(p[1])
+def p_ArgumentName(self, p):
+"""
+ArgumentName : IDENTIFIER
+| ATTRIBUTE
+| CALLBACK
+| CONST
+| CREATOR
+| DELETER
+| DICTIONARY
+| ENUM
+| EXCEPTION
+| GETTER
+| IMPLEMENTS
+| INHERIT
+| INTERFACE
+| LEGACYCALLER
+| PARTIAL
+| SERIALIZER
+| SETTER
+| STATIC
+| STRINGIFIER
+| JSONIFIER
+| TYPEDEF
+| UNRESTRICTED
+"""
+p[0] = p[1]
+def p_Optional(self, p):
+"""
+Optional : OPTIONAL
+"""
+p[0] = True
+def p_OptionalEmpty(self, p):
+"""
+Optional :
+"""
+p[0] = False
+def p_Ellipsis(self, p):
+"""
+Ellipsis : ELLIPSIS
+"""
+p[0] = True
+def p_EllipsisEmpty(self, p):
+"""
+Ellipsis :
+"""
+p[0] = False
+def p_ExceptionMember(self, p):
+"""
+ExceptionMember : Const
+| ExceptionField
+"""
+pass
+def p_ExceptionField(self, p):
+"""
+ExceptionField : Type IDENTIFIER SEMICOLON
+"""
+pass
+def p_ExtendedAttributeList(self, p):
+"""
+ExtendedAttributeList : LBRACKET ExtendedAttribute ExtendedAttributes RBRACKET
+"""
+p[0] = [p[2]]
+if p[3]:
+p[0].extend(p[3])
+def p_ExtendedAttributeListEmpty(self, p):
+"""
+ExtendedAttributeList :
+"""
+p[0] = []
+def p_ExtendedAttribute(self, p):
+"""
+ExtendedAttribute : ExtendedAttributeNoArgs
+| ExtendedAttributeArgList
+| ExtendedAttributeIdent
+| ExtendedAttributeNamedArgList
+"""
+p[0] = IDLExtendedAttribute(self.getLocation(p, 1), p[1])
+def p_ExtendedAttributeEmpty(self, p):
+"""
+ExtendedAttribute :
+"""
+pass
+def p_ExtendedAttributes(self, p):
+"""
+ExtendedAttributes : COMMA ExtendedAttribute ExtendedAttributes
+"""
+p[0] = [p[2]] if p[2] else []
+p[0].extend(p[3])
+def p_ExtendedAttributesEmpty(self, p):
+"""
+ExtendedAttributes :
+"""
+p[0] = []
+def p_Other(self, p):
+"""
+Other : INTEGER
+| FLOATLITERAL
+| IDENTIFIER
+| STRING
+| OTHER
+| ELLIPSIS
+| COLON
+| SCOPE
+| SEMICOLON
+| LT
+| EQUALS
+| GT
+| QUESTIONMARK
+| DATE
+| DOMSTRING
+| BYTESTRING
+| ANY
+| ATTRIBUTE
+| BOOLEAN
+| BYTE
+| LEGACYCALLER
+| CONST
+| CREATOR
+| DELETER
+| DOUBLE
+| EXCEPTION
+| FALSE
+| FLOAT
+| GETTER
+| IMPLEMENTS
+| INHERIT
+| INTERFACE
+| LONG
+| MODULE
+| NULL
+| OBJECT
+| OCTET
+| OPTIONAL
+| SEQUENCE
+| MOZMAP
+| SETTER
+| SHORT
+| STATIC
+| STRINGIFIER
+| JSONIFIER
+| TRUE
+| TYPEDEF
+| UNSIGNED
+| VOID
+"""
+pass
+def p_OtherOrComma(self, p):
+"""
+OtherOrComma : Other
+| COMMA
+"""
+pass
+def p_TypeSingleType(self, p):
+"""
+Type : SingleType
+"""
+p[0] = p[1]
+def p_TypeUnionType(self, p):
+"""
+Type : UnionType TypeSuffix
+"""
+p[0] = self.handleModifiers(p[1], p[2])
+def p_SingleTypeNonAnyType(self, p):
+"""
+SingleType : NonAnyType
+"""
+p[0] = p[1]
+def p_SingleTypeAnyType(self, p):
+"""
+SingleType : ANY TypeSuffixStartingWithArray
+"""
+p[0] = self.handleModifiers(BuiltinTypes[IDLBuiltinType.Types.any], p[2])
+def p_UnionType(self, p):
+"""
+UnionType : LPAREN UnionMemberType OR UnionMemberType UnionMemberTypes RPAREN
+"""
+types = [p[2], p[4]]
+types.extend(p[5])
+p[0] = IDLUnionType(self.getLocation(p, 1), types)
+def p_UnionMemberTypeNonAnyType(self, p):
+"""
+UnionMemberType : NonAnyType
+"""
+p[0] = p[1]
+def p_UnionMemberTypeArrayOfAny(self, p):
+"""
+UnionMemberTypeArrayOfAny : ANY LBRACKET RBRACKET
+"""
+p[0] = IDLArrayType(self.getLocation(p, 2),
+BuiltinTypes[IDLBuiltinType.Types.any])
+def p_UnionMemberType(self, p):
+"""
+UnionMemberType : UnionType TypeSuffix
+| UnionMemberTypeArrayOfAny TypeSuffix
+"""
+p[0] = self.handleModifiers(p[1], p[2])
+def p_UnionMemberTypes(self, p):
+"""
+UnionMemberTypes : OR UnionMemberType UnionMemberTypes
+"""
+p[0] = [p[2]]
+p[0].extend(p[3])
+def p_UnionMemberTypesEmpty(self, p):
+"""
+UnionMemberTypes :
+"""
+p[0] = []
+def p_NonAnyType(self, p):
+"""
+NonAnyType : PrimitiveOrStringType TypeSuffix
+| ARRAYBUFFER TypeSuffix
+| OBJECT TypeSuffix
+"""
+if p[1] == "object":
+type = BuiltinTypes[IDLBuiltinType.Types.object]
+elif p[1] == "ArrayBuffer":
+type = BuiltinTypes[IDLBuiltinType.Types.ArrayBuffer]
+else:
+type = BuiltinTypes[p[1]]
+p[0] = self.handleModifiers(type, p[2])
+def p_NonAnyTypeSequenceType(self, p):
+"""
+NonAnyType : SEQUENCE LT Type GT Null
+"""
+innerType = p[3]
+type = IDLSequenceType(self.getLocation(p, 1), innerType)
+if p[5]:
+type = IDLNullableType(self.getLocation(p, 5), type)
+p[0] = type
+def p_NonAnyTypeMozMapType(self, p):
+"""
+NonAnyType : MOZMAP LT Type GT Null
+"""
+innerType = p[3]
+type = IDLMozMapType(self.getLocation(p, 1), innerType)
+if p[5]:
+type = IDLNullableType(self.getLocation(p, 5), type)
+p[0] = type
+def p_NonAnyTypeScopedName(self, p):
+"""
+NonAnyType : ScopedName TypeSuffix
+"""
+assert isinstance(p[1], IDLUnresolvedIdentifier)
+type = None
+try:
+if self.globalScope()._lookupIdentifier(p[1]):
+obj = self.globalScope()._lookupIdentifier(p[1])
+if obj.isType():
+type = obj
+else:
+type = IDLWrapperType(self.getLocation(p, 1), p[1])
+p[0] = self.handleModifiers(type, p[2])
+return
+except:
+pass
+type = IDLUnresolvedType(self.getLocation(p, 1), p[1])
+p[0] = self.handleModifiers(type, p[2])
+def p_NonAnyTypeDate(self, p):
+"""
+NonAnyType : DATE TypeSuffix
+"""
+p[0] = self.handleModifiers(BuiltinTypes[IDLBuiltinType.Types.date],
+p[2])
+def p_ConstType(self, p):
+"""
+ConstType : PrimitiveOrStringType Null
+"""
+type = BuiltinTypes[p[1]]
+if p[2]:
+type = IDLNullableType(self.getLocation(p, 1), type)
+p[0] = type
+def p_ConstTypeIdentifier(self, p):
+"""
+ConstType : IDENTIFIER Null
+"""
+identifier = IDLUnresolvedIdentifier(self.getLocation(p, 1), p[1])
+type = IDLUnresolvedType(self.getLocation(p, 1), identifier)
+if p[2]:
+type = IDLNullableType(self.getLocation(p, 1), type)
+p[0] = type
+def p_PrimitiveOrStringTypeUint(self, p):
+"""
+PrimitiveOrStringType : UnsignedIntegerType
+"""
+p[0] = p[1]
+def p_PrimitiveOrStringTypeBoolean(self, p):
+"""
+PrimitiveOrStringType : BOOLEAN
+"""
+p[0] = IDLBuiltinType.Types.boolean
+def p_PrimitiveOrStringTypeByte(self, p):
+"""
+PrimitiveOrStringType : BYTE
+"""
+p[0] = IDLBuiltinType.Types.byte
+def p_PrimitiveOrStringTypeOctet(self, p):
+"""
+PrimitiveOrStringType : OCTET
+"""
+p[0] = IDLBuiltinType.Types.octet
+def p_PrimitiveOrStringTypeFloat(self, p):
+"""
+PrimitiveOrStringType : FLOAT
+"""
+p[0] = IDLBuiltinType.Types.float
+def p_PrimitiveOrStringTypeUnrestictedFloat(self, p):
+"""
+PrimitiveOrStringType : UNRESTRICTED FLOAT
+"""
+p[0] = IDLBuiltinType.Types.unrestricted_float
+def p_PrimitiveOrStringTypeDouble(self, p):
+"""
+PrimitiveOrStringType : DOUBLE
+"""
+p[0] = IDLBuiltinType.Types.double
+def p_PrimitiveOrStringTypeUnrestictedDouble(self, p):
+"""
+PrimitiveOrStringType : UNRESTRICTED DOUBLE
+"""
+p[0] = IDLBuiltinType.Types.unrestricted_double
+def p_PrimitiveOrStringTypeDOMString(self, p):
+"""
+PrimitiveOrStringType : DOMSTRING
+"""
+p[0] = IDLBuiltinType.Types.domstring
+def p_PrimitiveOrStringTypeBytestring(self, p):
+"""
+PrimitiveOrStringType : BYTESTRING
+"""
+p[0] = IDLBuiltinType.Types.bytestring
+def p_UnsignedIntegerTypeUnsigned(self, p):
+"""
+UnsignedIntegerType : UNSIGNED IntegerType
+"""
+p[0] = p[2] + 1 # Adding one to a given signed integer type
+# gets you the unsigned type.
+def p_UnsignedIntegerType(self, p):
+"""
+UnsignedIntegerType : IntegerType
+"""
+p[0] = p[1]
+def p_IntegerTypeShort(self, p):
+"""
+IntegerType : SHORT
+"""
+p[0] = IDLBuiltinType.Types.short
+def p_IntegerTypeLong(self, p):
+"""
+IntegerType : LONG OptionalLong
+"""
+if p[2]:
+p[0] = IDLBuiltinType.Types.long_long
+else:
+p[0] = IDLBuiltinType.Types.long
+def p_OptionalLong(self, p):
+"""
+OptionalLong : LONG
+"""
+p[0] = True
+def p_OptionalLongEmpty(self, p):
+"""
+OptionalLong :
+"""
+p[0] = False
+def p_TypeSuffixBrackets(self, p):
+"""
+TypeSuffix : LBRACKET RBRACKET TypeSuffix
+"""
+p[0] = [(IDLMethod.TypeSuffixModifier.Brackets, self.getLocation(p, 1))]
+p[0].extend(p[3])
+def p_TypeSuffixQMark(self, p):
+"""
+TypeSuffix : QUESTIONMARK TypeSuffixStartingWithArray
+"""
+p[0] = [(IDLMethod.TypeSuffixModifier.QMark, self.getLocation(p, 1))]
+p[0].extend(p[2])
+def p_TypeSuffixEmpty(self, p):
+"""
+TypeSuffix :
+"""
+p[0] = []
+def p_TypeSuffixStartingWithArray(self, p):
+"""
+TypeSuffixStartingWithArray : LBRACKET RBRACKET TypeSuffix
+"""
+p[0] = [(IDLMethod.TypeSuffixModifier.Brackets, self.getLocation(p, 1))]
+p[0].extend(p[3])
+def p_TypeSuffixStartingWithArrayEmpty(self, p):
+"""
+TypeSuffixStartingWithArray :
+"""
+p[0] = []
+def p_Null(self, p):
+"""
+Null : QUESTIONMARK
+|
+"""
+if len(p) > 1:
+p[0] = True
+else:
+p[0] = False
+def p_ReturnTypeType(self, p):
+"""
+ReturnType : Type
+"""
+p[0] = p[1]
+def p_ReturnTypeVoid(self, p):
+"""
+ReturnType : VOID
+"""
+p[0] = BuiltinTypes[IDLBuiltinType.Types.void]
+def p_ScopedName(self, p):
+"""
+ScopedName : AbsoluteScopedName
+| RelativeScopedName
+"""
+p[0] = p[1]
+def p_AbsoluteScopedName(self, p):
+"""
+AbsoluteScopedName : SCOPE IDENTIFIER ScopedNameParts
+"""
+assert False
+pass
+def p_RelativeScopedName(self, p):
+"""
+RelativeScopedName : IDENTIFIER ScopedNameParts
+"""
+assert not p[2] # Not implemented!
+p[0] = IDLUnresolvedIdentifier(self.getLocation(p, 1), p[1])
+def p_ScopedNameParts(self, p):
+"""
+ScopedNameParts : SCOPE IDENTIFIER ScopedNameParts
+"""
+assert False
+pass
+def p_ScopedNamePartsEmpty(self, p):
+"""
+ScopedNameParts :
+"""
+p[0] = None
+def p_ExtendedAttributeNoArgs(self, p):
+"""
+ExtendedAttributeNoArgs : IDENTIFIER
+"""
+p[0] = (p[1],)
+def p_ExtendedAttributeArgList(self, p):
+"""
+ExtendedAttributeArgList : IDENTIFIER LPAREN ArgumentList RPAREN
+"""
+p[0] = (p[1], p[3])
+def p_ExtendedAttributeIdent(self, p):
+"""
+ExtendedAttributeIdent : IDENTIFIER EQUALS STRING
+| IDENTIFIER EQUALS IDENTIFIER
+"""
+p[0] = (p[1], p[3])
+def p_ExtendedAttributeNamedArgList(self, p):
+"""
+ExtendedAttributeNamedArgList : IDENTIFIER EQUALS IDENTIFIER LPAREN ArgumentList RPAREN
+"""
+p[0] = (p[1], p[3], p[5])
+def p_error(self, p):
+if not p:
+raise WebIDLError("Syntax Error at end of file. Possibly due to missing semicolon(;), braces(}) or both",
+[self._filename])
+else:
+raise WebIDLError("invalid syntax", [Location(self.lexer, p.lineno, p.lexpos, self._filename)])
+def __init__(self, outputdir='', lexer=None):
+Tokenizer.__init__(self, outputdir, lexer)
+self.parser = yacc.yacc(module=self,
+outputdir=outputdir,
+tabmodule='webidlyacc',
+errorlog=yacc.NullLogger(),
+picklefile='WebIDLGrammar.pkl')
+self._globalScope = IDLScope(BuiltinLocation("<Global Scope>"), None, None)
+self._installBuiltins(self._globalScope)
+self._productions = []
+self._filename = "<builtin>"
+self.lexer.input(Parser._builtins)
+self._filename = None
+self.parser.parse(lexer=self.lexer,tracking=True)
+def _installBuiltins(self, scope):
+assert isinstance(scope, IDLScope)
+# xrange omits the last value.
+for x in xrange(IDLBuiltinType.Types.ArrayBuffer, IDLBuiltinType.Types.Float64Array + 1):
+builtin = BuiltinTypes[x]
+name = builtin.name
+typedef = IDLTypedefType(BuiltinLocation("<builtin type>"), builtin, name)
+typedef.resolve(scope)
+@ staticmethod
+def handleModifiers(type, modifiers):
+for (modifier, modifierLocation) in modifiers:
+assert modifier == IDLMethod.TypeSuffixModifier.QMark or \
+modifier == IDLMethod.TypeSuffixModifier.Brackets
+if modifier == IDLMethod.TypeSuffixModifier.QMark:
+type = IDLNullableType(modifierLocation, type)
+elif modifier == IDLMethod.TypeSuffixModifier.Brackets:
+type = IDLArrayType(modifierLocation, type)
+return type
+def parse(self, t, filename=None):
+self.lexer.input(t)
+#for tok in iter(self.lexer.token, None):
+#    print tok
+self._filename = filename
+self._productions.extend(self.parser.parse(lexer=self.lexer,tracking=True))
+self._filename = None
+def finish(self):
+# First, finish all the IDLImplementsStatements.  In particular, we
+# have to make sure we do those before we do the IDLInterfaces.
+# XXX khuey hates this bit and wants to nuke it from orbit.
+implementsStatements = [ p for p in self._productions if
+isinstance(p, IDLImplementsStatement)]
+otherStatements = [ p for p in self._productions if
+not isinstance(p, IDLImplementsStatement)]
+for production in implementsStatements:
+production.finish(self.globalScope())
+for production in otherStatements:
+production.finish(self.globalScope())
+# Do any post-finish validation we need to do
+for production in self._productions:
+production.validate()
+# De-duplicate self._productions, without modifying its order.
+seen = set()
+result = []
+for p in self._productions:
+if p not in seen:
+seen.add(p)
+result.append(p)
+return result
+def reset(self):
+return Parser(lexer=self.lexer)
+# Builtin IDL defined by WebIDL
+_builtins = """
+typedef unsigned long long DOMTimeStamp;
+"""
+def main():
+# Parse arguments.
+from optparse import OptionParser
+usageString = "usage: %prog [options] files"
+o = OptionParser(usage=usageString)
+o.add_option("--cachedir", dest='cachedir', default=None,
+help="Directory in which to cache lex/parse tables.")
+o.add_option("--verbose-errors", action='store_true', default=False,
+help="When an error happens, display the Python traceback.")
+(options, args) = o.parse_args()
+if len(args) < 1:
+o.error(usageString)
+fileList = args
+baseDir = os.getcwd()
+# Parse the WebIDL.
+parser = Parser(options.cachedir)
+try:
+for filename in fileList:
+fullPath = os.path.normpath(os.path.join(baseDir, filename))
+f = open(fullPath, 'rb')
+lines = f.readlines()
+f.close()
+print fullPath
+parser.parse(''.join(lines), fullPath)
+parser.finish()
+except WebIDLError, e:
+if options.verbose_errors:
+traceback.print_exc()
+else:
+print e
+if __name__ == '__main__':
+main()

The Tor Browser / file comparison

comparison: dom/bindings/parser/WebIDL.py

dom/bindings/parser/WebIDL.py