gecko-dev/xpcom/idl-parser/xpidl.py

1422 строки
46 KiB
Python

#!/usr/bin/env python
# xpidl.py - A parser for cross-platform IDL (XPIDL) files.
#
# 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 parser for cross-platform IDL (XPIDL) files."""
import sys, os.path, re
from ply import lex, yacc
"""A type conforms to the following pattern:
def isScriptable(self):
'returns True or False'
def nativeType(self, calltype):
'returns a string representation of the native type
calltype must be 'in', 'out', or 'inout'
Interface members const/method/attribute conform to the following pattern:
name = 'string'
def toIDL(self):
'returns the member signature as IDL'
"""
def attlistToIDL(attlist):
if len(attlist) == 0:
return ''
attlist = list(attlist)
attlist.sort(cmp=lambda a,b: cmp(a[0], b[0]))
return '[%s] ' % ','.join(["%s%s" % (name, value is not None and '(%s)' % value or '')
for name, value, aloc in attlist])
_paramsHardcode = {
2: ('array', 'shared', 'iid_is', 'size_is', 'retval'),
3: ('array', 'size_is', 'const'),
}
def paramAttlistToIDL(attlist):
if len(attlist) == 0:
return ''
# Hack alert: g_hash_table_foreach is pretty much unimitatable... hardcode
# quirk
attlist = list(attlist)
sorted = []
if len(attlist) in _paramsHardcode:
for p in _paramsHardcode[len(attlist)]:
i = 0
while i < len(attlist):
if attlist[i][0] == p:
sorted.append(attlist[i])
del attlist[i]
continue
i += 1
sorted.extend(attlist)
return '[%s] ' % ', '.join(["%s%s" % (name, value is not None and ' (%s)' % value or '')
for name, value, aloc in sorted])
def unaliasType(t):
while t.kind == 'typedef':
t = t.realtype
assert t is not None
return t
def getBuiltinOrNativeTypeName(t):
t = unaliasType(t)
if t.kind == 'builtin':
return t.name
elif t.kind == 'native':
assert t.specialtype is not None
return '[%s]' % t.specialtype
else:
return None
class BuiltinLocation(object):
def get(self):
return "<builtin type>"
def __str__(self):
return self.get()
class Builtin(object):
kind = 'builtin'
location = BuiltinLocation
def __init__(self, name, nativename, signed=False, maybeConst=False):
self.name = name
self.nativename = nativename
self.signed = signed
self.maybeConst = maybeConst
def isScriptable(self):
return True
def nativeType(self, calltype, shared=False, const=False):
if const:
print >>sys.stderr, IDLError("[const] doesn't make sense on builtin types.", self.location, warning=True)
const = 'const '
elif calltype == 'in' and self.nativename.endswith('*'):
const = 'const '
elif shared:
if not self.nativename.endswith('*'):
raise IDLError("[shared] not applicable to non-pointer types.", self.location)
const = 'const '
else:
const = ''
return "%s%s %s" % (const, self.nativename,
calltype != 'in' and '*' or '')
builtinNames = [
Builtin('boolean', 'bool'),
Builtin('void', 'void'),
Builtin('octet', 'uint8_t'),
Builtin('short', 'int16_t', True, True),
Builtin('long', 'int32_t', True, True),
Builtin('long long', 'int64_t', True, False),
Builtin('unsigned short', 'uint16_t', False, True),
Builtin('unsigned long', 'uint32_t', False, True),
Builtin('unsigned long long', 'uint64_t', False, False),
Builtin('float', 'float', True, False),
Builtin('double', 'double', True, False),
Builtin('char', 'char', True, False),
Builtin('string', 'char *', False, False),
Builtin('wchar', 'char16_t', False, False),
Builtin('wstring', 'char16_t *', False, False),
]
builtinMap = {}
for b in builtinNames:
builtinMap[b.name] = b
class Location(object):
_line = None
def __init__(self, lexer, lineno, lexpos):
self._lineno = lineno
self._lexpos = lexpos
self._lexdata = lexer.lexdata
self._file = getattr(lexer, 'filename', "<unknown>")
def __eq__(self, other):
return self._lexpos == other._lexpos and \
self._file == other._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)
self._line = self._lexdata[startofline:endofline]
self._colno = self._lexpos - startofline
def pointerline(self):
def i():
for i in xrange(0, self._colno):
yield " "
yield "^"
return "".join(i())
def get(self):
self.resolve()
return "%s line %s:%s" % (self._file, self._lineno, 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 NameMap(object):
"""Map of name -> object. Each object must have a .name and .location property.
Setting the same name twice throws an error."""
def __init__(self):
self._d = {}
def __getitem__(self, key):
if key in builtinMap:
return builtinMap[key]
return self._d[key]
def __iter__(self):
return self._d.itervalues()
def __contains__(self, key):
return key in builtinMap or key in self._d
def set(self, object):
if object.name in builtinMap:
raise IDLError("name '%s' is a builtin and cannot be redeclared" % (object.name), object.location)
if object.name.startswith("_"):
object.name = object.name[1:]
if object.name in self._d:
old = self._d[object.name]
if old == object: return
if isinstance(old, Forward) and isinstance(object, Interface):
self._d[object.name] = object
elif isinstance(old, Interface) and isinstance(object, Forward):
pass
else:
raise IDLError("name '%s' specified twice. Previous location: %s" % (object.name, self._d[object.name].location), object.location)
else:
self._d[object.name] = object
def get(self, id, location):
try:
return self[id]
except KeyError:
raise IDLError("Name '%s' not found", location)
class IDLError(Exception):
def __init__(self, message, location, warning=False):
self.message = message
self.location = location
self.warning = warning
def __str__(self):
return "%s: %s, %s" % (self.warning and 'warning' or 'error',
self.message, self.location)
class Include(object):
kind = 'include'
def __init__(self, filename, location):
self.filename = filename
self.location = location
def __str__(self):
return "".join(["include '%s'\n" % self.filename])
def resolve(self, parent):
def incfiles():
yield self.filename
for dir in parent.incdirs:
yield os.path.join(dir, self.filename)
for file in incfiles():
if not os.path.exists(file): continue
self.IDL = parent.parser.parse(open(file).read(), filename=file)
self.IDL.resolve(parent.incdirs, parent.parser)
for type in self.IDL.getNames():
parent.setName(type)
parent.deps.extend(self.IDL.deps)
return
raise IDLError("File '%s' not found" % self.filename, self.location)
class IDL(object):
def __init__(self, productions):
self.productions = productions
self.deps = []
def setName(self, object):
self.namemap.set(object)
def getName(self, id, location):
try:
return self.namemap[id]
except KeyError:
raise IDLError("type '%s' not found" % id, location)
def hasName(self, id):
return id in self.namemap
def getNames(self):
return iter(self.namemap)
def __str__(self):
return "".join([str(p) for p in self.productions])
def resolve(self, incdirs, parser):
self.namemap = NameMap()
self.incdirs = incdirs
self.parser = parser
for p in self.productions:
p.resolve(self)
def includes(self):
for p in self.productions:
if p.kind == 'include':
yield p
def needsJSTypes(self):
for p in self.productions:
if p.kind == 'interface' and p.needsJSTypes():
return True
return False
class CDATA(object):
kind = 'cdata'
_re = re.compile(r'\n+')
def __init__(self, data, location):
self.data = self._re.sub('\n', data)
self.location = location
def resolve(self, parent):
pass
def __str__(self):
return "cdata: %s\n\t%r\n" % (self.location.get(), self.data)
def count(self):
return 0
class Typedef(object):
kind = 'typedef'
def __init__(self, type, name, location, doccomments):
self.type = type
self.name = name
self.location = location
self.doccomments = doccomments
def __eq__(self, other):
return self.name == other.name and self.type == other.type
def resolve(self, parent):
parent.setName(self)
self.realtype = parent.getName(self.type, self.location)
def isScriptable(self):
return self.realtype.isScriptable()
def nativeType(self, calltype):
return "%s %s" % (self.name,
calltype != 'in' and '*' or '')
def __str__(self):
return "typedef %s %s\n" % (self.type, self.name)
class Forward(object):
kind = 'forward'
def __init__(self, name, location, doccomments):
self.name = name
self.location = location
self.doccomments = doccomments
def __eq__(self, other):
return other.kind == 'forward' and other.name == self.name
def resolve(self, parent):
# Hack alert: if an identifier is already present, move the doccomments
# forward.
if parent.hasName(self.name):
for i in xrange(0, len(parent.productions)):
if parent.productions[i] is self: break
for i in xrange(i + 1, len(parent.productions)):
if hasattr(parent.productions[i], 'doccomments'):
parent.productions[i].doccomments[0:0] = self.doccomments
break
parent.setName(self)
def isScriptable(self):
return True
def nativeType(self, calltype):
return "%s %s" % (self.name,
calltype != 'in' and '* *' or '*')
def __str__(self):
return "forward-declared %s\n" % self.name
class Native(object):
kind = 'native'
modifier = None
specialtype = None
specialtypes = {
'nsid': None,
'domstring': 'nsAString',
'utf8string': 'nsACString',
'cstring': 'nsACString',
'astring': 'nsAString',
'jsval': 'JS::Value'
}
def __init__(self, name, nativename, attlist, location):
self.name = name
self.nativename = nativename
self.location = location
for name, value, aloc in attlist:
if value is not None:
raise IDLError("Unexpected attribute value", aloc)
if name in ('ptr', 'ref'):
if self.modifier is not None:
raise IDLError("More than one ptr/ref modifier", aloc)
self.modifier = name
elif name in self.specialtypes.keys():
if self.specialtype is not None:
raise IDLError("More than one special type", aloc)
self.specialtype = name
if self.specialtypes[name] is not None:
self.nativename = self.specialtypes[name]
else:
raise IDLError("Unexpected attribute", aloc)
def __eq__(self, other):
return self.name == other.name and \
self.nativename == other.nativename and \
self.modifier == other.modifier and \
self.specialtype == other.specialtype
def resolve(self, parent):
parent.setName(self)
def isScriptable(self):
if self.specialtype is None:
return False
if self.specialtype == 'nsid':
return self.modifier is not None
return self.modifier == 'ref'
def isPtr(self, calltype):
return self.modifier == 'ptr'
def isRef(self, calltype):
return self.modifier == 'ref'
def nativeType(self, calltype, const=False, shared=False):
if shared:
if calltype != 'out':
raise IDLError("[shared] only applies to out parameters.")
const = True
if self.specialtype is not None and calltype == 'in':
const = True
if self.specialtype == 'jsval':
if calltype == 'out' or calltype == 'inout':
return "JS::MutableHandleValue "
return "JS::HandleValue "
if self.isRef(calltype):
m = '& '
elif self.isPtr(calltype):
m = '*' + ((self.modifier == 'ptr' and calltype != 'in') and '*' or '')
else:
m = calltype != 'in' and '*' or ''
return "%s%s %s" % (const and 'const ' or '', self.nativename, m)
def __str__(self):
return "native %s(%s)\n" % (self.name, self.nativename)
class Interface(object):
kind = 'interface'
def __init__(self, name, attlist, base, members, location, doccomments):
self.name = name
self.attributes = InterfaceAttributes(attlist, location)
self.base = base
self.members = members
self.location = location
self.namemap = NameMap()
self.doccomments = doccomments
self.nativename = name
for m in members:
if not isinstance(m, CDATA):
self.namemap.set(m)
def __eq__(self, other):
return self.name == other.name and self.location == other.location
def resolve(self, parent):
self.idl = parent
# Hack alert: if an identifier is already present, libIDL assigns
# doc comments incorrectly. This is quirks-mode extraordinaire!
if parent.hasName(self.name):
for member in self.members:
if hasattr(member, 'doccomments'):
member.doccomments[0:0] = self.doccomments
break
self.doccomments = parent.getName(self.name, None).doccomments
if self.attributes.function:
has_method = False
for member in self.members:
if member.kind is 'method':
if has_method:
raise IDLError("interface '%s' has multiple methods, but marked 'function'" % self.name, self.location)
else:
has_method = True
parent.setName(self)
if self.base is not None:
realbase = parent.getName(self.base, self.location)
if realbase.kind != 'interface':
raise IDLError("interface '%s' inherits from non-interface type '%s'" % (self.name, self.base), self.location)
if self.attributes.scriptable and not realbase.attributes.scriptable:
print >>sys.stderr, IDLError("interface '%s' is scriptable but derives from non-scriptable '%s'" % (self.name, self.base), self.location, warning=True)
if self.attributes.scriptable and realbase.attributes.builtinclass and not self.attributes.builtinclass:
raise IDLError("interface '%s' is not builtinclass but derives from builtinclass '%s'" % (self.name, self.base), self.location)
for member in self.members:
member.resolve(self)
# The number 250 is NOT arbitrary; this number is the maximum number of
# stub entries defined in xpcom/reflect/xptcall/public/genstubs.pl
# Do not increase this value without increasing the number in that
# location, or you WILL cause otherwise unknown problems!
if self.countEntries() > 250 and not self.attributes.builtinclass:
raise IDLError("interface '%s' has too many entries" % self.name,
self.location)
def isScriptable(self):
# NOTE: this is not whether *this* interface is scriptable... it's
# whether, when used as a type, it's scriptable, which is true of all
# interfaces.
return True
def nativeType(self, calltype, const=False):
return "%s%s %s" % (const and 'const ' or '',
self.name,
calltype != 'in' and '* *' or '*')
def __str__(self):
l = ["interface %s\n" % self.name]
if self.base is not None:
l.append("\tbase %s\n" % self.base)
l.append(str(self.attributes))
if self.members is None:
l.append("\tincomplete type\n")
else:
for m in self.members:
l.append(str(m))
return "".join(l)
def getConst(self, name, location):
# The constant may be in a base class
iface = self
while name not in iface.namemap and iface is not None:
iface = self.idl.getName(self.base, self.location)
if iface is None:
raise IDLError("cannot find symbol '%s'" % name, c.location)
c = iface.namemap.get(name, location)
if c.kind != 'const':
raise IDLError("symbol '%s' is not a constant", c.location)
return c.getValue()
def needsJSTypes(self):
for m in self.members:
if m.kind == "attribute" and m.type == "jsval":
return True
if m.kind == "method" and m.needsJSTypes():
return True
return False
def countEntries(self):
''' Returns the number of entries in the vtable for this interface. '''
total = sum(member.count() for member in self.members)
if self.base is not None:
realbase = self.idl.getName(self.base, self.location)
total += realbase.countEntries()
return total
class InterfaceAttributes(object):
uuid = None
scriptable = False
builtinclass = False
function = False
deprecated = False
noscript = False
def setuuid(self, value):
self.uuid = value.lower()
def setscriptable(self):
self.scriptable = True
def setfunction(self):
self.function = True
def setnoscript(self):
self.noscript = True
def setbuiltinclass(self):
self.builtinclass = True
def setdeprecated(self):
self.deprecated = True
actions = {
'uuid': (True, setuuid),
'scriptable': (False, setscriptable),
'builtinclass': (False, setbuiltinclass),
'function': (False, setfunction),
'noscript': (False, setnoscript),
'deprecated': (False, setdeprecated),
'object': (False, lambda self: True),
}
def __init__(self, attlist, location):
def badattribute(self):
raise IDLError("Unexpected interface attribute '%s'" % name, location)
for name, val, aloc in attlist:
hasval, action = self.actions.get(name, (False, badattribute))
if hasval:
if val is None:
raise IDLError("Expected value for attribute '%s'" % name,
aloc)
action(self, val)
else:
if val is not None:
raise IDLError("Unexpected value for attribute '%s'" % name,
aloc)
action(self)
if self.uuid is None:
raise IDLError("interface has no uuid", location)
def __str__(self):
l = []
if self.uuid:
l.append("\tuuid: %s\n" % self.uuid)
if self.scriptable:
l.append("\tscriptable\n")
if self.builtinclass:
l.append("\tbuiltinclass\n")
if self.function:
l.append("\tfunction\n")
return "".join(l)
class ConstMember(object):
kind = 'const'
def __init__(self, type, name, value, location, doccomments):
self.type = type
self.name = name
self.value = value
self.location = location
self.doccomments = doccomments
def resolve(self, parent):
self.realtype = parent.idl.getName(self.type, self.location)
self.iface = parent
basetype = self.realtype
while isinstance(basetype, Typedef):
basetype = basetype.realtype
if not isinstance(basetype, Builtin) or not basetype.maybeConst:
raise IDLError("const may only be a short or long type, not %s" % self.type, self.location)
self.basetype = basetype
def getValue(self):
return self.value(self.iface)
def __str__(self):
return "\tconst %s %s = %s\n" % (self.type, self.name, self.getValue())
def count(self):
return 0
class Attribute(object):
kind = 'attribute'
noscript = False
readonly = False
implicit_jscontext = False
nostdcall = False
binaryname = None
null = None
undefined = None
deprecated = False
infallible = False
def __init__(self, type, name, attlist, readonly, location, doccomments):
self.type = type
self.name = name
self.attlist = attlist
self.readonly = readonly
self.location = location
self.doccomments = doccomments
for name, value, aloc in attlist:
if name == 'binaryname':
if value is None:
raise IDLError("binaryname attribute requires a value",
aloc)
self.binaryname = value
continue
if name == 'Null':
if value is None:
raise IDLError("'Null' attribute requires a value", aloc)
if readonly:
raise IDLError("'Null' attribute only makes sense for setters",
aloc);
if value not in ('Empty', 'Null', 'Stringify'):
raise IDLError("'Null' attribute value must be 'Empty', 'Null' or 'Stringify'",
aloc);
self.null = value
elif name == 'Undefined':
if value is None:
raise IDLError("'Undefined' attribute requires a value", aloc)
if readonly:
raise IDLError("'Undefined' attribute only makes sense for setters",
aloc);
if value not in ('Empty', 'Null'):
raise IDLError("'Undefined' attribute value must be 'Empty' or 'Null'",
aloc);
self.undefined = value
else:
if value is not None:
raise IDLError("Unexpected attribute value", aloc)
if name == 'noscript':
self.noscript = True
elif name == 'implicit_jscontext':
self.implicit_jscontext = True
elif name == 'deprecated':
self.deprecated = True
elif name == 'nostdcall':
self.nostdcall = True
elif name == 'infallible':
self.infallible = True
else:
raise IDLError("Unexpected attribute '%s'" % name, aloc)
def resolve(self, iface):
self.iface = iface
self.realtype = iface.idl.getName(self.type, self.location)
if (self.null is not None and
getBuiltinOrNativeTypeName(self.realtype) != '[domstring]'):
raise IDLError("'Null' attribute can only be used on DOMString",
self.location)
if (self.undefined is not None and
getBuiltinOrNativeTypeName(self.realtype) != '[domstring]'):
raise IDLError("'Undefined' attribute can only be used on DOMString",
self.location)
if self.infallible and not self.realtype.kind == 'builtin':
raise IDLError('[infallible] only works on builtin types '
'(numbers, booleans, and raw char types)',
self.location)
if self.infallible and not iface.attributes.builtinclass:
raise IDLError('[infallible] attributes are only allowed on '
'[builtinclass] interfaces',
self.location)
def toIDL(self):
attribs = attlistToIDL(self.attlist)
readonly = self.readonly and 'readonly ' or ''
return "%s%sattribute %s %s;" % (attribs, readonly, self.type, self.name)
def isScriptable(self):
if not self.iface.attributes.scriptable: return False
return not self.noscript
def __str__(self):
return "\t%sattribute %s %s\n" % (self.readonly and 'readonly ' or '',
self.type, self.name)
def count(self):
return self.readonly and 1 or 2
class Method(object):
kind = 'method'
noscript = False
notxpcom = False
binaryname = None
implicit_jscontext = False
nostdcall = False
optional_argc = False
deprecated = False
def __init__(self, type, name, attlist, paramlist, location, doccomments, raises):
self.type = type
self.name = name
self.attlist = attlist
self.params = paramlist
self.location = location
self.doccomments = doccomments
self.raises = raises
for name, value, aloc in attlist:
if name == 'binaryname':
if value is None:
raise IDLError("binaryname attribute requires a value",
aloc)
self.binaryname = value
continue
if value is not None:
raise IDLError("Unexpected attribute value", aloc)
if name == 'noscript':
self.noscript = True
elif name == 'notxpcom':
self.notxpcom = True
elif name == 'implicit_jscontext':
self.implicit_jscontext = True
elif name == 'optional_argc':
self.optional_argc = True
elif name == 'deprecated':
self.deprecated = True
elif name == 'nostdcall':
self.nostdcall = True
else:
raise IDLError("Unexpected attribute '%s'" % name, aloc)
self.namemap = NameMap()
for p in paramlist:
self.namemap.set(p)
def resolve(self, iface):
self.iface = iface
self.realtype = self.iface.idl.getName(self.type, self.location)
for p in self.params:
p.resolve(self)
for p in self.params:
if p.retval and p != self.params[-1]:
raise IDLError("'retval' parameter '%s' is not the last parameter" % p.name, self.location)
if p.size_is:
found_size_param = False
for size_param in self.params:
if p.size_is == size_param.name:
found_size_param = True
if getBuiltinOrNativeTypeName(size_param.realtype) != 'unsigned long':
raise IDLError("is_size parameter must have type 'unsigned long'", self.location)
if not found_size_param:
raise IDLError("could not find is_size parameter '%s'" % p.size_is, self.location)
def isScriptable(self):
if not self.iface.attributes.scriptable: return False
return not (self.noscript or self.notxpcom)
def __str__(self):
return "\t%s %s(%s)\n" % (self.type, self.name, ", ".join([p.name for p in self.params]))
def toIDL(self):
if len(self.raises):
raises = ' raises (%s)' % ','.join(self.raises)
else:
raises = ''
return "%s%s %s (%s)%s;" % (attlistToIDL(self.attlist),
self.type,
self.name,
", ".join([p.toIDL()
for p in self.params]),
raises)
def needsJSTypes(self):
if self.implicit_jscontext:
return True
if self.type == "jsval":
return True
for p in self.params:
t = p.realtype
if isinstance(t, Native) and t.specialtype == "jsval":
return True
return False
def count(self):
return 1
class Param(object):
size_is = None
iid_is = None
const = False
array = False
retval = False
shared = False
optional = False
null = None
undefined = None
def __init__(self, paramtype, type, name, attlist, location, realtype=None):
self.paramtype = paramtype
self.type = type
self.name = name
self.attlist = attlist
self.location = location
self.realtype = realtype
for name, value, aloc in attlist:
# Put the value-taking attributes first!
if name == 'size_is':
if value is None:
raise IDLError("'size_is' must specify a parameter", aloc)
self.size_is = value
elif name == 'iid_is':
if value is None:
raise IDLError("'iid_is' must specify a parameter", aloc)
self.iid_is = value
elif name == 'Null':
if value is None:
raise IDLError("'Null' must specify a parameter", aloc)
if value not in ('Empty', 'Null', 'Stringify'):
raise IDLError("'Null' parameter value must be 'Empty', 'Null', or 'Stringify'",
aloc);
self.null = value
elif name == 'Undefined':
if value is None:
raise IDLError("'Undefined' must specify a parameter", aloc)
if value not in ('Empty', 'Null'):
raise IDLError("'Undefined' parameter value must be 'Empty' or 'Null'",
aloc);
self.undefined = value
else:
if value is not None:
raise IDLError("Unexpected value for attribute '%s'" % name,
aloc)
if name == 'const':
self.const = True
elif name == 'array':
self.array = True
elif name == 'retval':
self.retval = True
elif name == 'shared':
self.shared = True
elif name == 'optional':
self.optional = True
else:
raise IDLError("Unexpected attribute '%s'" % name, aloc)
def resolve(self, method):
self.realtype = method.iface.idl.getName(self.type, self.location)
if self.array:
self.realtype = Array(self.realtype)
if (self.null is not None and
getBuiltinOrNativeTypeName(self.realtype) != '[domstring]'):
raise IDLError("'Null' attribute can only be used on DOMString",
self.location)
if (self.undefined is not None and
getBuiltinOrNativeTypeName(self.realtype) != '[domstring]'):
raise IDLError("'Undefined' attribute can only be used on DOMString",
self.location)
def nativeType(self):
kwargs = {}
if self.shared: kwargs['shared'] = True
if self.const: kwargs['const'] = True
try:
return self.realtype.nativeType(self.paramtype, **kwargs)
except IDLError, e:
raise IDLError(e.message, self.location)
except TypeError, e:
raise IDLError("Unexpected parameter attribute", self.location)
def toIDL(self):
return "%s%s %s %s" % (paramAttlistToIDL(self.attlist),
self.paramtype,
self.type,
self.name)
class Array(object):
def __init__(self, basetype):
self.type = basetype
def isScriptable(self):
return self.type.isScriptable()
def nativeType(self, calltype, const=False):
return "%s%s*" % (const and 'const ' or '',
self.type.nativeType(calltype))
class IDLParser(object):
keywords = {
'const': 'CONST',
'interface': 'INTERFACE',
'in': 'IN',
'inout': 'INOUT',
'out': 'OUT',
'attribute': 'ATTRIBUTE',
'raises': 'RAISES',
'readonly': 'READONLY',
'native': 'NATIVE',
'typedef': 'TYPEDEF',
'Infinity': 'INFINITY'
}
tokens = [
'IDENTIFIER',
'CDATA',
'INCLUDE',
'IID',
'NUMBER',
'HEXNUM',
'LSHIFT',
'RSHIFT',
'NATIVEID',
]
tokens.extend(keywords.values())
states = (
('nativeid', 'exclusive'),
)
hexchar = r'[a-fA-F0-9]'
t_NUMBER = r'-?\d+'
t_HEXNUM = r'0x%s+' % hexchar
t_LSHIFT = r'<<'
t_RSHIFT= r'>>'
literals = '"(){}[],;:=|+-*'
t_ignore = ' \t'
def t_multilinecomment(self, t):
r'/\*(?s).*?\*/'
t.lexer.lineno += t.value.count('\n')
if t.value.startswith("/**"):
self._doccomments.append(t.value)
def t_singlelinecomment(self, t):
r'(?m)//.*?$'
def t_IID(self, t):
return t
t_IID.__doc__ = r'%(c)s{8}-%(c)s{4}-%(c)s{4}-%(c)s{4}-%(c)s{12}' % {'c': hexchar}
def t_IDENTIFIER(self, t):
r'(unsigned\ long\ long|unsigned\ short|unsigned\ long|long\ long)(?!_?[A-Za-z][A-Za-z_0-9])|_?[A-Za-z][A-Za-z_0-9]*'
t.type = self.keywords.get(t.value, 'IDENTIFIER')
return t
def t_LCDATA(self, t):
r'(?s)%\{[ ]*C\+\+[ ]*\n(?P<cdata>.*?\n?)%\}[ ]*(C\+\+)?'
t.type = 'CDATA'
t.value = t.lexer.lexmatch.group('cdata')
t.lexer.lineno += t.value.count('\n')
return t
def t_INCLUDE(self, t):
r'\#include[ \t]+"[^"\n]+"'
inc, value, end = t.value.split('"')
t.value = value
return t
def t_directive(self, t):
r'\#(?P<directive>[a-zA-Z]+)[^\n]+'
raise IDLError("Unrecognized directive %s" % t.lexer.lexmatch.group('directive'),
Location(lexer=self.lexer, lineno=self.lexer.lineno,
lexpos=self.lexer.lexpos))
def t_newline(self, t):
r'\n+'
t.lexer.lineno += len(t.value)
def t_nativeid_NATIVEID(self, t):
r'[^()\n]+(?=\))'
t.lexer.begin('INITIAL')
return t
t_nativeid_ignore = ''
def t_ANY_error(self, t):
raise IDLError("unrecognized input",
Location(lexer=self.lexer,
lineno=self.lexer.lineno,
lexpos=self.lexer.lexpos))
precedence = (
('left', '|'),
('left', 'LSHIFT', 'RSHIFT'),
('left', '+', '-'),
('left', '*'),
('left', 'UMINUS'),
)
def p_idlfile(self, p):
"""idlfile : productions"""
p[0] = IDL(p[1])
def p_productions_start(self, p):
"""productions : """
p[0] = []
def p_productions_cdata(self, p):
"""productions : CDATA productions"""
p[0] = list(p[2])
p[0].insert(0, CDATA(p[1], self.getLocation(p, 1)))
def p_productions_include(self, p):
"""productions : INCLUDE productions"""
p[0] = list(p[2])
p[0].insert(0, Include(p[1], self.getLocation(p, 1)))
def p_productions_interface(self, p):
"""productions : interface productions
| typedef productions
| native productions"""
p[0] = list(p[2])
p[0].insert(0, p[1])
def p_typedef(self, p):
"""typedef : TYPEDEF IDENTIFIER IDENTIFIER ';'"""
p[0] = Typedef(type=p[2],
name=p[3],
location=self.getLocation(p, 1),
doccomments=p.slice[1].doccomments)
def p_native(self, p):
"""native : attributes NATIVE IDENTIFIER afternativeid '(' NATIVEID ')' ';'"""
p[0] = Native(name=p[3],
nativename=p[6],
attlist=p[1]['attlist'],
location=self.getLocation(p, 2))
def p_afternativeid(self, p):
"""afternativeid : """
# this is a place marker: we switch the lexer into literal identifier
# mode here, to slurp up everything until the closeparen
self.lexer.begin('nativeid')
def p_anyident(self, p):
"""anyident : IDENTIFIER
| CONST"""
p[0] = {'value': p[1],
'location': self.getLocation(p, 1)}
def p_attributes(self, p):
"""attributes : '[' attlist ']'
| """
if len(p) == 1:
p[0] = {'attlist': []}
else:
p[0] = {'attlist': p[2],
'doccomments': p.slice[1].doccomments}
def p_attlist_start(self, p):
"""attlist : attribute"""
p[0] = [p[1]]
def p_attlist_continue(self, p):
"""attlist : attribute ',' attlist"""
p[0] = list(p[3])
p[0].insert(0, p[1])
def p_attribute(self, p):
"""attribute : anyident attributeval"""
p[0] = (p[1]['value'], p[2], p[1]['location'])
def p_attributeval(self, p):
"""attributeval : '(' IDENTIFIER ')'
| '(' IID ')'
| """
if len(p) > 1:
p[0] = p[2]
def p_interface(self, p):
"""interface : attributes INTERFACE IDENTIFIER ifacebase ifacebody ';'"""
atts, INTERFACE, name, base, body, SEMI = p[1:]
attlist = atts['attlist']
doccomments = []
if 'doccomments' in atts:
doccomments.extend(atts['doccomments'])
doccomments.extend(p.slice[2].doccomments)
l = lambda: self.getLocation(p, 2)
if body is None:
# forward-declared interface... must not have attributes!
if len(attlist) != 0:
raise IDLError("Forward-declared interface must not have attributes",
list[0][3])
if base is not None:
raise IDLError("Forward-declared interface must not have a base",
l())
p[0] = Forward(name=name, location=l(), doccomments=doccomments)
else:
p[0] = Interface(name=name,
attlist=attlist,
base=base,
members=body,
location=l(),
doccomments=doccomments)
def p_ifacebody(self, p):
"""ifacebody : '{' members '}'
| """
if len(p) > 1:
p[0] = p[2]
def p_ifacebase(self, p):
"""ifacebase : ':' IDENTIFIER
| """
if len(p) == 3:
p[0] = p[2]
def p_members_start(self, p):
"""members : """
p[0] = []
def p_members_continue(self, p):
"""members : member members"""
p[0] = list(p[2])
p[0].insert(0, p[1])
def p_member_cdata(self, p):
"""member : CDATA"""
p[0] = CDATA(p[1], self.getLocation(p, 1))
def p_member_const(self, p):
"""member : CONST IDENTIFIER IDENTIFIER '=' number ';' """
p[0] = ConstMember(type=p[2], name=p[3],
value=p[5], location=self.getLocation(p, 1),
doccomments=p.slice[1].doccomments)
# All "number" products return a function(interface)
def p_number_decimal(self, p):
"""number : NUMBER"""
n = int(p[1])
p[0] = lambda i: n
def p_number_hex(self, p):
"""number : HEXNUM"""
n = int(p[1], 16)
p[0] = lambda i: n
def p_number_identifier(self, p):
"""number : IDENTIFIER"""
id = p[1]
loc = self.getLocation(p, 1)
p[0] = lambda i: i.getConst(id, loc)
def p_number_paren(self, p):
"""number : '(' number ')'"""
p[0] = p[2]
def p_number_neg(self, p):
"""number : '-' number %prec UMINUS"""
n = p[2]
p[0] = lambda i: - n(i)
def p_number_add(self, p):
"""number : number '+' number
| number '-' number
| number '*' number"""
n1 = p[1]
n2 = p[3]
if p[2] == '+':
p[0] = lambda i: n1(i) + n2(i)
elif p[2] == '-':
p[0] = lambda i: n1(i) - n2(i)
else:
p[0] = lambda i: n1(i) * n2(i)
def p_number_shift(self, p):
"""number : number LSHIFT number
| number RSHIFT number"""
n1 = p[1]
n2 = p[3]
if p[2] == '<<':
p[0] = lambda i: n1(i) << n2(i)
else:
p[0] = lambda i: n1(i) >> n2(i)
def p_number_bitor(self, p):
"""number : number '|' number"""
n1 = p[1]
n2 = p[3]
p[0] = lambda i: n1(i) | n2(i)
def p_member_att(self, p):
"""member : attributes optreadonly ATTRIBUTE IDENTIFIER IDENTIFIER ';'"""
if 'doccomments' in p[1]:
doccomments = p[1]['doccomments']
elif p[2] is not None:
doccomments = p[2]
else:
doccomments = p.slice[3].doccomments
p[0] = Attribute(type=p[4],
name=p[5],
attlist=p[1]['attlist'],
readonly=p[2] is not None,
location=self.getLocation(p, 3),
doccomments=doccomments)
def p_member_method(self, p):
"""member : attributes IDENTIFIER IDENTIFIER '(' paramlist ')' raises ';'"""
if 'doccomments' in p[1]:
doccomments = p[1]['doccomments']
else:
doccomments = p.slice[2].doccomments
p[0] = Method(type=p[2],
name=p[3],
attlist=p[1]['attlist'],
paramlist=p[5],
location=self.getLocation(p, 3),
doccomments=doccomments,
raises=p[7])
def p_paramlist(self, p):
"""paramlist : param moreparams
| """
if len(p) == 1:
p[0] = []
else:
p[0] = list(p[2])
p[0].insert(0, p[1])
def p_moreparams_start(self, p):
"""moreparams :"""
p[0] = []
def p_moreparams_continue(self, p):
"""moreparams : ',' param moreparams"""
p[0] = list(p[3])
p[0].insert(0, p[2])
def p_param(self, p):
"""param : attributes paramtype IDENTIFIER IDENTIFIER"""
p[0] = Param(paramtype=p[2],
type=p[3],
name=p[4],
attlist=p[1]['attlist'],
location=self.getLocation(p, 3))
def p_paramtype(self, p):
"""paramtype : IN
| INOUT
| OUT"""
p[0] = p[1]
def p_optreadonly(self, p):
"""optreadonly : READONLY
| """
if len(p) > 1:
p[0] = p.slice[1].doccomments
else:
p[0] = None
def p_raises(self, p):
"""raises : RAISES '(' idlist ')'
| """
if len(p) == 1:
p[0] = []
else:
p[0] = p[3]
def p_idlist(self, p):
"""idlist : IDENTIFIER"""
p[0] = [p[1]]
def p_idlist_continue(self, p):
"""idlist : IDENTIFIER ',' idlist"""
p[0] = list(p[3])
p[0].insert(0, p[1])
def p_error(self, t):
if not t:
raise IDLError("Syntax Error at end of file. Possibly due to missing semicolon(;), braces(}) or both", None)
else:
location = Location(self.lexer, t.lineno, t.lexpos)
raise IDLError("invalid syntax", location)
def __init__(self, outputdir=''):
self._doccomments = []
self.lexer = lex.lex(object=self,
outputdir=outputdir,
lextab='xpidllex',
optimize=1)
self.parser = yacc.yacc(module=self,
outputdir=outputdir,
debug=0,
tabmodule='xpidlyacc',
optimize=1)
def clearComments(self):
self._doccomments = []
def token(self):
t = self.lexer.token()
if t is not None and t.type != 'CDATA':
t.doccomments = self._doccomments
self._doccomments = []
return t
def parse(self, data, filename=None):
if filename is not None:
self.lexer.filename = filename
self.lexer.lineno = 1
self.lexer.input(data)
idl = self.parser.parse(lexer=self)
if filename is not None:
idl.deps.append(filename)
return idl
def getLocation(self, p, i):
return Location(self.lexer, p.lineno(i), p.lexpos(i))
if __name__ == '__main__':
p = IDLParser()
for f in sys.argv[1:]:
print "Parsing %s" % f
p.parse(open(f).read(), filename=f)