forked from mirrors/gecko-dev
b3f3e9a04a
These properties were previously being checked much later, during xptcodegen, and causing methods to be treated as noscript implicitly. This change enforces the noscript requirements earlier when possible in xpidl.py, to produce better errors, and adds addiitonal checks to ensure that types which need to be builtinclass are marked as such. This required some changes to interfaces in order to satisfy the new checks. Differential Revision: https://phabricator.services.mozilla.com/D207804
2302 lines
73 KiB
Python
Executable file
2302 lines
73 KiB
Python
Executable file
#!/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 os.path
|
|
import re
|
|
import sys
|
|
import textwrap
|
|
from collections import namedtuple
|
|
|
|
import six
|
|
from ply import lex, yacc
|
|
|
|
"""A type conforms to the following pattern:
|
|
|
|
def nativeType(self, calltype):
|
|
'returns a string representation of the native type
|
|
calltype must be 'in', 'out', 'inout', or 'element'
|
|
|
|
Interface members const/method/attribute conform to the following pattern:
|
|
|
|
name = 'string'
|
|
|
|
def toIDL(self):
|
|
'returns the member signature as IDL'
|
|
"""
|
|
|
|
|
|
# XXX(nika): Fix the IDL files which do this so we can remove this list?
|
|
def rustPreventForward(s):
|
|
"""These types are foward declared as interfaces, but never actually defined
|
|
in IDL files. We don't want to generate references to them in rust for that
|
|
reason."""
|
|
return s in (
|
|
"nsIFrame",
|
|
"nsSubDocumentFrame",
|
|
)
|
|
|
|
|
|
def attlistToIDL(attlist):
|
|
if len(attlist) == 0:
|
|
return ""
|
|
|
|
attlist = list(attlist)
|
|
attlist.sort(key=lambda a: a[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, rustname, tsname, signed=False, maybeConst=False
|
|
):
|
|
self.name = name
|
|
self.nativename = nativename
|
|
self.rustname = rustname
|
|
self.tsname = tsname
|
|
self.signed = signed
|
|
self.maybeConst = maybeConst
|
|
|
|
def isPointer(self):
|
|
"""Check if this type is a pointer type - this will control how pointers act"""
|
|
return self.nativename.endswith("*")
|
|
|
|
def nativeType(self, calltype, shared=False, const=False):
|
|
if self.name in ["string", "wstring"] and calltype == "element":
|
|
raise IDLError(
|
|
"Use string class types for string Array elements", self.location
|
|
)
|
|
|
|
if const:
|
|
print(
|
|
IDLError(
|
|
"[const] doesn't make sense on builtin types.",
|
|
self.location,
|
|
warning=True,
|
|
),
|
|
file=sys.stderr,
|
|
)
|
|
const = "const "
|
|
elif calltype == "in" and self.isPointer():
|
|
const = "const "
|
|
elif shared:
|
|
if not self.isPointer():
|
|
raise IDLError(
|
|
"[shared] not applicable to non-pointer types.", self.location
|
|
)
|
|
const = "const "
|
|
else:
|
|
const = ""
|
|
return "%s%s %s" % (const, self.nativename, "*" if "out" in calltype else "")
|
|
|
|
def rustType(self, calltype, shared=False, const=False):
|
|
# We want to rewrite any *mut pointers to *const pointers if constness
|
|
# was requested.
|
|
const = const or ("out" not in calltype and self.isPointer()) or shared
|
|
rustname = self.rustname
|
|
if const and self.isPointer():
|
|
rustname = self.rustname.replace("*mut", "*const")
|
|
|
|
return "%s%s" % ("*mut " if "out" in calltype else "", rustname)
|
|
|
|
def tsType(self):
|
|
if self.tsname:
|
|
return self.tsname
|
|
|
|
raise TSNoncompat(f"Builtin type {self.name} unsupported in TypeScript")
|
|
|
|
|
|
builtinNames = [
|
|
Builtin("boolean", "bool", "bool", "boolean"),
|
|
Builtin("void", "void", "libc::c_void", "void"),
|
|
Builtin("int8_t", "int8_t", "i8", "i8", True, True),
|
|
Builtin("int16_t", "int16_t", "i16", "i16", True, True),
|
|
Builtin("int32_t", "int32_t", "i32", "i32", True, True),
|
|
Builtin("int64_t", "int64_t", "i64", "i64", True, True),
|
|
Builtin("uint8_t", "uint8_t", "u8", "u8", False, True),
|
|
Builtin("uint16_t", "uint16_t", "u16", "u16", False, True),
|
|
Builtin("uint32_t", "uint32_t", "u32", "u32", False, True),
|
|
Builtin("uint64_t", "uint64_t", "u64", "u64", False, True),
|
|
Builtin("nsresult", "nsresult", "nserror::nsresult", "nsresult"),
|
|
Builtin("float", "float", "libc::c_float", "float"),
|
|
Builtin("double", "double", "libc::c_double", "double"),
|
|
Builtin("char", "char", "libc::c_char", "string"),
|
|
Builtin("string", "char *", "*const libc::c_char", "string"),
|
|
Builtin("wchar", "char16_t", "u16", "string"),
|
|
Builtin("wstring", "char16_t *", "*const u16", "string"),
|
|
# NOTE: char16_t is the same type as `wchar` in C++, however it is reflected
|
|
# into JS as an integer, allowing it to be used in constants.
|
|
# This inconsistency sucks, but reflects existing usage so unfortunately
|
|
# isn't very easy to change.
|
|
Builtin("char16_t", "char16_t", "u16", "u16", False, True),
|
|
# As seen in mfbt/RefCountType.h, this type has special handling to
|
|
# maintain binary compatibility with MSCOM's IUnknown that cannot be
|
|
# expressed in XPIDL.
|
|
Builtin(
|
|
"MozExternalRefCountType",
|
|
"MozExternalRefCountType",
|
|
"MozExternalRefCountType",
|
|
None,
|
|
),
|
|
]
|
|
|
|
# Allow using more C-style names for the basic integer types.
|
|
builtinAlias = [
|
|
("octet", "uint8_t"),
|
|
("unsigned short", "uint16_t"),
|
|
("unsigned long", "uint32_t"),
|
|
("unsigned long long", "uint64_t"),
|
|
("short", "int16_t"),
|
|
("long", "int32_t"),
|
|
("long long", "int64_t"),
|
|
]
|
|
|
|
builtinMap = {}
|
|
for b in builtinNames:
|
|
builtinMap[b.name] = b
|
|
|
|
for alias, name in builtinAlias:
|
|
builtinMap[alias] = builtinMap[name]
|
|
|
|
|
|
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 range(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 six.itervalues(self._d)
|
|
|
|
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(f"Name '{id}' not found", location)
|
|
|
|
|
|
class RustNoncompat(Exception):
|
|
"""
|
|
This exception is raised when a particular type or function cannot be safely exposed to
|
|
rust code
|
|
"""
|
|
|
|
def __init__(self, reason):
|
|
self.reason = reason
|
|
|
|
def __str__(self):
|
|
return self.reason
|
|
|
|
|
|
class TSNoncompat(Exception):
|
|
"""Raised when a type cannot be exposed to TypeScript."""
|
|
|
|
def __init__(self, reason):
|
|
self.reason = reason
|
|
|
|
def __str__(self):
|
|
return self.reason
|
|
|
|
|
|
class IDLError(Exception):
|
|
def __init__(self, message, location, warning=False, notes=None):
|
|
self.message = message
|
|
self.location = location
|
|
self.warning = warning
|
|
self.notes = notes
|
|
|
|
def __str__(self):
|
|
error = "%s: %s, %s" % (
|
|
self.warning and "warning" or "error",
|
|
self.message,
|
|
self.location,
|
|
)
|
|
if self.notes is not None:
|
|
error += "\nnote: %s" % self.notes
|
|
return error
|
|
|
|
|
|
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
|
|
|
|
if file in parent.includeCache:
|
|
self.IDL = parent.includeCache[file]
|
|
else:
|
|
self.IDL = parent.parser.parse(
|
|
open(file, encoding="utf-8").read(), filename=file
|
|
)
|
|
self.IDL.resolve(
|
|
parent.incdirs,
|
|
parent.parser,
|
|
parent.webidlconfig,
|
|
parent.includeCache,
|
|
)
|
|
parent.includeCache[file] = self.IDL
|
|
|
|
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.hasSequence = False
|
|
self.productions = productions
|
|
self.deps = []
|
|
|
|
def setName(self, object):
|
|
self.namemap.set(object)
|
|
|
|
def getName(self, id, location):
|
|
if id.name == "Array":
|
|
if id.params is None or len(id.params) != 1:
|
|
raise IDLError("Array takes exactly 1 parameter", location)
|
|
self.hasSequence = True
|
|
return Array(self.getName(id.params[0], location), location)
|
|
|
|
if id.params is not None:
|
|
raise IDLError("Generic type '%s' unrecognized" % id.name, location)
|
|
|
|
try:
|
|
return self.namemap[id.name]
|
|
except KeyError:
|
|
raise IDLError("type '%s' not found" % id.name, 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, webidlconfig, includeCache=None):
|
|
self.namemap = NameMap()
|
|
self.incdirs = incdirs
|
|
self.parser = parser
|
|
self.webidlconfig = webidlconfig
|
|
self.includeCache = {} if includeCache is None else includeCache
|
|
for p in self.productions:
|
|
p.resolve(self)
|
|
|
|
def includes(self):
|
|
for p in self.productions:
|
|
if p.kind == "include":
|
|
yield p
|
|
if self.hasSequence:
|
|
yield Include("nsTArray.h", BuiltinLocation)
|
|
|
|
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):
|
|
# This can be a false-positive if the word `virtual` is included in a
|
|
# comment, however this doesn't seem to happen very often.
|
|
if isinstance(parent, Interface) and re.search(r"\bvirtual\b", self.data):
|
|
raise IDLError(
|
|
"cannot declare a C++ `virtual` member in XPIDL interface",
|
|
self.location,
|
|
notes=textwrap.fill(
|
|
"""All virtual members must be declared directly using XPIDL.
|
|
Both the Rust bindings and XPConnect rely on the per-platform
|
|
vtable layouts generated by the XPIDL compiler to allow
|
|
cross-language XPCOM method calls between JS and C++.
|
|
Consider using a `[notxpcom, nostdcall]` method instead."""
|
|
),
|
|
)
|
|
|
|
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, attlist, 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)
|
|
|
|
if not isinstance(self.realtype, (Builtin, CEnum, Native, Typedef)):
|
|
raise IDLError("Unsupported typedef target type", self.location)
|
|
|
|
def nativeType(self, calltype):
|
|
return "%s %s" % (self.name, "*" if "out" in calltype else "")
|
|
|
|
def rustType(self, calltype):
|
|
return "%s%s" % ("*mut " if "out" in calltype else "", self.name)
|
|
|
|
def tsType(self):
|
|
# Make sure that underlying type is supported: doesn't throw TSNoncompat.
|
|
self.realtype.tsType()
|
|
return self.name
|
|
|
|
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 range(0, len(parent.productions)):
|
|
if parent.productions[i] is self:
|
|
break
|
|
for i in range(i + 1, len(parent.productions)):
|
|
if hasattr(parent.productions[i], "doccomments"):
|
|
parent.productions[i].doccomments[0:0] = self.doccomments
|
|
break
|
|
|
|
parent.setName(self)
|
|
|
|
def nativeType(self, calltype):
|
|
if calltype == "element":
|
|
return "RefPtr<%s>" % self.name
|
|
return "%s *%s" % (self.name, "*" if "out" in calltype else "")
|
|
|
|
def rustType(self, calltype):
|
|
if rustPreventForward(self.name):
|
|
raise RustNoncompat("forward declaration %s is unsupported" % self.name)
|
|
if calltype == "element":
|
|
return "Option<RefPtr<%s>>" % self.name
|
|
return "%s*const %s" % ("*mut" if "out" in calltype else "", self.name)
|
|
|
|
def tsType(self):
|
|
return self.name
|
|
|
|
def __str__(self):
|
|
return "forward-declared %s\n" % self.name
|
|
|
|
|
|
class Native(object):
|
|
kind = "native"
|
|
|
|
modifier = None
|
|
specialtype = None
|
|
|
|
# A tuple type here means that a custom value is used for each calltype:
|
|
# (in, out/inout, array element) respectively.
|
|
# A `None` here means that the written type should be used as-is.
|
|
specialtypes = {
|
|
"nsid": None,
|
|
"utf8string": ("const nsACString&", "nsACString&", "nsCString"),
|
|
"cstring": ("const nsACString&", "nsACString&", "nsCString"),
|
|
"astring": ("const nsAString&", "nsAString&", "nsString"),
|
|
"jsval": ("JS::Handle<JS::Value>", "JS::MutableHandle<JS::Value>", "JS::Value"),
|
|
"promise": "::mozilla::dom::Promise",
|
|
}
|
|
|
|
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 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.", self.location
|
|
)
|
|
const = True
|
|
|
|
if isinstance(self.nativename, tuple):
|
|
if calltype == "in":
|
|
return self.nativename[0] + " "
|
|
elif "out" in calltype:
|
|
return self.nativename[1] + " "
|
|
else:
|
|
return self.nativename[2] + " "
|
|
|
|
# 'in' nsid parameters should be made 'const'
|
|
if self.specialtype == "nsid" and calltype == "in":
|
|
const = True
|
|
|
|
if calltype == "element":
|
|
if self.specialtype == "nsid":
|
|
if self.isPtr(calltype):
|
|
raise IDLError(
|
|
"Array<nsIDPtr> not yet supported. "
|
|
"File an XPConnect bug if you need it.",
|
|
self.location,
|
|
)
|
|
|
|
# ns[CI]?IDs should be held directly in Array<T>s
|
|
return self.nativename
|
|
|
|
if self.isRef(calltype):
|
|
raise IDLError(
|
|
"[ref] qualified type unsupported in Array<T>", self.location
|
|
)
|
|
|
|
# Promises should be held in RefPtr<T> in Array<T>s
|
|
if self.specialtype == "promise":
|
|
return "RefPtr<mozilla::dom::Promise>"
|
|
|
|
if self.isRef(calltype):
|
|
m = "& " # [ref] is always passed with a single indirection
|
|
else:
|
|
m = "* " if "out" in calltype else ""
|
|
if self.isPtr(calltype):
|
|
m += "* "
|
|
return "%s%s %s" % (const and "const " or "", self.nativename, m)
|
|
|
|
def rustType(self, calltype, const=False, shared=False):
|
|
# For the most part, 'native' types don't make sense in rust, as they
|
|
# are native C++ types. However, we can support a few types here, as
|
|
# they're important and can easily be translated.
|
|
#
|
|
# NOTE: This code doesn't try to perfectly match C++ constness, as
|
|
# constness doesn't affect ABI, and raw pointers are already unsafe.
|
|
|
|
if self.modifier not in ["ptr", "ref"]:
|
|
raise RustNoncompat("Rust only supports [ref] / [ptr] native types")
|
|
|
|
if shared:
|
|
if calltype != "out":
|
|
raise IDLError(
|
|
"[shared] only applies to out parameters.", self.location
|
|
)
|
|
const = True
|
|
|
|
# 'in' nsid parameters should be made 'const'
|
|
if self.specialtype == "nsid" and calltype == "in":
|
|
const = True
|
|
|
|
prefix = "*const " if const or shared else "*mut "
|
|
if "out" in calltype and self.isPtr(calltype):
|
|
prefix = "*mut " + prefix
|
|
|
|
if self.specialtype:
|
|
# The string types are very special, and need to be handled seperately.
|
|
if self.specialtype in ["cstring", "utf8string"]:
|
|
if calltype == "in":
|
|
return "*const ::nsstring::nsACString"
|
|
elif "out" in calltype:
|
|
return "*mut ::nsstring::nsACString"
|
|
else:
|
|
return "::nsstring::nsCString"
|
|
if self.specialtype == "astring":
|
|
if calltype == "in":
|
|
return "*const ::nsstring::nsAString"
|
|
elif "out" in calltype:
|
|
return "*mut ::nsstring::nsAString"
|
|
else:
|
|
return "::nsstring::nsString"
|
|
# nsid has some special handling, but generally re-uses the generic
|
|
# prefix handling above.
|
|
if self.specialtype == "nsid":
|
|
if "element" in calltype:
|
|
if self.isPtr(calltype):
|
|
raise IDLError(
|
|
"Array<nsIDPtr> not yet supported. "
|
|
"File an XPConnect bug if you need it.",
|
|
self.location,
|
|
)
|
|
return self.nativename
|
|
return prefix + self.nativename
|
|
raise RustNoncompat("special type %s unsupported" % self.specialtype)
|
|
|
|
# These 3 special types correspond to native pointer types which can
|
|
# generally be supported behind pointers. Other types are not supported
|
|
# for now.
|
|
if self.nativename == "void":
|
|
return prefix + "libc::c_void"
|
|
if self.nativename == "char":
|
|
return prefix + "libc::c_char"
|
|
if self.nativename == "char16_t":
|
|
return prefix + "u16"
|
|
|
|
raise RustNoncompat("native type %s unsupported" % self.nativename)
|
|
|
|
ts_special = {
|
|
"astring": "string",
|
|
"cstring": "string",
|
|
"jsval": "any",
|
|
"nsid": "nsID",
|
|
"promise": "Promise<any>",
|
|
"utf8string": "string",
|
|
}
|
|
|
|
def tsType(self):
|
|
if type := self.ts_special.get(self.specialtype, None):
|
|
return type
|
|
|
|
raise TSNoncompat(f"Native type {self.name} unsupported in TypeScript")
|
|
|
|
def __str__(self):
|
|
return "native %s(%s)\n" % (self.name, self.nativename)
|
|
|
|
|
|
class WebIDL(object):
|
|
kind = "webidl"
|
|
|
|
def __init__(self, name, location):
|
|
self.name = name
|
|
self.location = location
|
|
|
|
def __eq__(self, other):
|
|
return other.kind == "webidl" and self.name == other.name
|
|
|
|
def resolve(self, parent):
|
|
# XXX(nika): We don't handle _every_ kind of webidl object here (as that
|
|
# would be hard). For example, we don't support nsIDOM*-defaulting
|
|
# interfaces.
|
|
# TODO: More explicit compile-time checks?
|
|
|
|
assert (
|
|
parent.webidlconfig is not None
|
|
), "WebIDL declarations require passing webidlconfig to resolve."
|
|
|
|
# Resolve our native name according to the WebIDL configs.
|
|
config = parent.webidlconfig.get(self.name, {})
|
|
self.native = config.get("nativeType")
|
|
if self.native is None:
|
|
self.native = "mozilla::dom::%s" % self.name
|
|
self.headerFile = config.get("headerFile")
|
|
if self.headerFile is None:
|
|
self.headerFile = self.native.replace("::", "/") + ".h"
|
|
|
|
parent.setName(self)
|
|
|
|
def nativeType(self, calltype, const=False):
|
|
if calltype == "element":
|
|
return "RefPtr<%s%s>" % ("const " if const else "", self.native)
|
|
return "%s%s *%s" % (
|
|
"const " if const else "",
|
|
self.native,
|
|
"*" if "out" in calltype else "",
|
|
)
|
|
|
|
def rustType(self, calltype, const=False):
|
|
# Just expose the type as a void* - we can't do any better.
|
|
return "%s*const libc::c_void" % ("*mut " if "out" in calltype else "")
|
|
|
|
def tsType(self):
|
|
return self.name
|
|
|
|
def __str__(self):
|
|
return "webidl %s\n" % self.name
|
|
|
|
|
|
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
|
|
|
|
if not self.attributes.scriptable and self.attributes.builtinclass:
|
|
raise IDLError(
|
|
"Non-scriptable interface '%s' doesn't need to be marked builtinclass"
|
|
% self.name,
|
|
self.location,
|
|
)
|
|
|
|
# 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(TypeId(self.name), None).doccomments
|
|
|
|
if self.attributes.function:
|
|
has_method = False
|
|
for member in self.members:
|
|
if member.kind == "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(TypeId(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:
|
|
raise 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,
|
|
)
|
|
|
|
if realbase.attributes.rust_sync and not self.attributes.rust_sync:
|
|
raise IDLError(
|
|
"interface '%s' is not rust_sync but derives from rust_sync '%s'"
|
|
% (self.name, self.base),
|
|
self.location,
|
|
)
|
|
|
|
if (
|
|
self.attributes.rust_sync
|
|
and self.attributes.scriptable
|
|
and not self.attributes.builtinclass
|
|
):
|
|
raise IDLError(
|
|
"interface '%s' is rust_sync but is not builtinclass" % self.name,
|
|
self.location,
|
|
)
|
|
elif self.name != "nsISupports":
|
|
raise IDLError(
|
|
"Interface '%s' must inherit from nsISupports" % self.name,
|
|
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/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 nativeType(self, calltype, const=False):
|
|
if calltype == "element":
|
|
return "RefPtr<%s>" % self.name
|
|
return "%s%s *%s" % (
|
|
"const " if const else "",
|
|
self.name,
|
|
"*" if "out" in calltype else "",
|
|
)
|
|
|
|
def rustType(self, calltype, const=False):
|
|
if calltype == "element":
|
|
return "Option<RefPtr<%s>>" % self.name
|
|
return "%s*const %s" % ("*mut " if "out" in calltype else "", self.name)
|
|
|
|
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.base is not None:
|
|
iface = self.idl.getName(TypeId(iface.base), self.location)
|
|
if name not in iface.namemap:
|
|
raise IDLError("cannot find symbol '%s'" % name, location)
|
|
c = iface.namemap.get(name, location)
|
|
if c.kind != "const":
|
|
raise IDLError("symbol '%s' is not a constant" % name, location)
|
|
|
|
return c.getValue()
|
|
|
|
def needsJSTypes(self):
|
|
for m in self.members:
|
|
if m.kind == "attribute" and m.type == TypeId("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(TypeId(self.base), self.location)
|
|
total += realbase.countEntries()
|
|
return total
|
|
|
|
def tsType(self):
|
|
return self.name
|
|
|
|
|
|
class InterfaceAttributes(object):
|
|
uuid = None
|
|
scriptable = False
|
|
builtinclass = False
|
|
function = False
|
|
main_process_scriptable_only = False
|
|
rust_sync = False
|
|
|
|
def setuuid(self, value):
|
|
self.uuid = value.lower()
|
|
|
|
def setscriptable(self):
|
|
self.scriptable = True
|
|
|
|
def setfunction(self):
|
|
self.function = True
|
|
|
|
def setbuiltinclass(self):
|
|
self.builtinclass = True
|
|
|
|
def setmain_process_scriptable_only(self):
|
|
self.main_process_scriptable_only = True
|
|
|
|
def setrust_sync(self):
|
|
self.rust_sync = True
|
|
|
|
actions = {
|
|
"uuid": (True, setuuid),
|
|
"scriptable": (False, setscriptable),
|
|
"builtinclass": (False, setbuiltinclass),
|
|
"function": (False, setfunction),
|
|
"object": (False, lambda self: True),
|
|
"main_process_scriptable_only": (False, setmain_process_scriptable_only),
|
|
"rust_sync": (False, setrust_sync),
|
|
}
|
|
|
|
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")
|
|
if self.main_process_scriptable_only:
|
|
l.append("\tmain_process_scriptable_only\n")
|
|
if self.rust_sync:
|
|
l.append("\trust_sync\n")
|
|
return "".join(l)
|
|
|
|
|
|
class ConstMember(object):
|
|
kind = "const"
|
|
|
|
def __init__(self, type, name, value, location, doccomments):
|
|
self.type = type
|
|
self.name = name
|
|
self.valueFn = 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 an integer type, not %s" % self.type.name,
|
|
self.location,
|
|
)
|
|
|
|
self.basetype = basetype
|
|
# Value is a lambda. Resolve it.
|
|
self.value = self.valueFn(self.iface)
|
|
|
|
min_val = -(2**31) if basetype.signed else 0
|
|
max_val = 2**31 - 1 if basetype.signed else 2**32 - 1
|
|
if self.value < min_val or self.value > max_val:
|
|
raise IDLError(
|
|
"xpidl constants must fit within %s"
|
|
% ("int32_t" if basetype.signed else "uint32_t"),
|
|
self.location,
|
|
)
|
|
|
|
def getValue(self):
|
|
return self.value
|
|
|
|
def __str__(self):
|
|
return "\tconst %s %s = %s\n" % (self.type, self.name, self.getValue())
|
|
|
|
def count(self):
|
|
return 0
|
|
|
|
|
|
# Represents a single name/value pair in a CEnum
|
|
class CEnumVariant(object):
|
|
# Treat CEnumVariants as consts in terms of value resolution, so we can
|
|
# do things like binary operation values for enum members.
|
|
kind = "const"
|
|
|
|
def __init__(self, name, value, location):
|
|
self.name = name
|
|
self.valueFn = value
|
|
self.location = location
|
|
|
|
def getValue(self):
|
|
return self.value
|
|
|
|
|
|
class CEnum(object):
|
|
kind = "cenum"
|
|
|
|
def __init__(self, width, name, variants, location, doccomments):
|
|
# We have to set a name here, otherwise we won't pass namemap checks on
|
|
# the interface. This name will change it in resolve(), in order to
|
|
# namespace the enum within the interface.
|
|
self.name = name
|
|
self.basename = name
|
|
self.width = width
|
|
self.location = location
|
|
self.namemap = NameMap()
|
|
self.doccomments = doccomments
|
|
self.variants = variants
|
|
if self.width not in (8, 16, 32):
|
|
raise IDLError("Width must be one of {8, 16, 32}", self.location)
|
|
|
|
def resolve(self, iface):
|
|
self.iface = iface
|
|
# Renaming enum to faux-namespace the enum type to the interface in JS
|
|
# so we don't collide in the global namespace. Hacky/ugly but it does
|
|
# the job well enough, and the name will still be interface::variant in
|
|
# C++.
|
|
self.name = "%s_%s" % (self.iface.name, self.basename)
|
|
self.iface.idl.setName(self)
|
|
|
|
# Compute the value for each enum variant that doesn't set its own
|
|
# value
|
|
next_value = 0
|
|
for variant in self.variants:
|
|
# CEnum variants resolve to interface level consts in javascript,
|
|
# meaning their names could collide with other interface members.
|
|
# Iterate through all CEnum variants to make sure there are no
|
|
# collisions.
|
|
self.iface.namemap.set(variant)
|
|
# Value may be a lambda. If it is, resolve it.
|
|
if variant.valueFn:
|
|
next_value = variant.value = variant.valueFn(self.iface)
|
|
else:
|
|
variant.value = next_value
|
|
next_value += 1
|
|
|
|
def count(self):
|
|
return 0
|
|
|
|
def nativeType(self, calltype):
|
|
if "out" in calltype:
|
|
return "%s::%s *" % (self.iface.name, self.basename)
|
|
return "%s::%s " % (self.iface.name, self.basename)
|
|
|
|
def rustType(self, calltype):
|
|
return "%s u%d" % ("*mut" if "out" in calltype else "", self.width)
|
|
|
|
def tsType(self):
|
|
return f"{self.iface.name}.{self.basename}"
|
|
|
|
def __str__(self):
|
|
body = ", ".join("%s = %s" % v for v in self.variants)
|
|
return "\tcenum %s : %d { %s };\n" % (self.name, self.width, body)
|
|
|
|
|
|
# Infallible doesn't work for all return types.
|
|
#
|
|
# It also must be implemented on a builtinclass (otherwise it'd be unsound as
|
|
# it could be implemented by JS).
|
|
def ensureInfallibleIsSound(methodOrAttribute):
|
|
if not methodOrAttribute.infallible:
|
|
return
|
|
if methodOrAttribute.realtype.kind not in [
|
|
"builtin",
|
|
"interface",
|
|
"forward",
|
|
"webidl",
|
|
"cenum",
|
|
]:
|
|
raise IDLError(
|
|
"[infallible] only works on interfaces, domobjects, and builtin types "
|
|
"(numbers, booleans, cenum, and raw char types)",
|
|
methodOrAttribute.location,
|
|
)
|
|
ifaceAttributes = methodOrAttribute.iface.attributes
|
|
if ifaceAttributes.scriptable and not ifaceAttributes.builtinclass:
|
|
raise IDLError(
|
|
"[infallible] attributes and methods are only allowed on "
|
|
"non-[scriptable] or [builtinclass] interfaces",
|
|
methodOrAttribute.location,
|
|
)
|
|
|
|
if methodOrAttribute.notxpcom:
|
|
raise IDLError(
|
|
"[infallible] does not make sense for a [notxpcom] method or attribute",
|
|
methodOrAttribute.location,
|
|
)
|
|
|
|
|
|
# An interface cannot be implemented by JS if it has a notxpcom or nostdcall
|
|
# method or attribute, or uses a by-value native type, so it must be marked as
|
|
# builtinclass.
|
|
def ensureBuiltinClassIfNeeded(methodOrAttribute):
|
|
iface = methodOrAttribute.iface
|
|
if not iface.attributes.scriptable or iface.attributes.builtinclass:
|
|
return
|
|
if iface.name == "nsISupports":
|
|
return
|
|
|
|
# notxpcom and nostdcall types change calling conventions, which breaks
|
|
# xptcall wrappers. We cannot allow XPCWrappedJS to be created for
|
|
# interfaces with these methods.
|
|
if methodOrAttribute.notxpcom:
|
|
raise IDLError(
|
|
(
|
|
"scriptable interface '%s' must be marked [builtinclass] because it "
|
|
"contains a [notxpcom] %s '%s'"
|
|
)
|
|
% (iface.name, methodOrAttribute.kind, methodOrAttribute.name),
|
|
methodOrAttribute.location,
|
|
)
|
|
if methodOrAttribute.nostdcall:
|
|
raise IDLError(
|
|
(
|
|
"scriptable interface '%s' must be marked [builtinclass] because it "
|
|
"contains a [nostdcall] %s '%s'"
|
|
)
|
|
% (iface.name, methodOrAttribute.kind, methodOrAttribute.name),
|
|
methodOrAttribute.location,
|
|
)
|
|
|
|
# Methods with custom native parameters passed without indirection cannot be
|
|
# safely handled by xptcall (as it cannot know the calling stack/register
|
|
# layout), so require the interface to be builtinclass.
|
|
#
|
|
# Only "in" parameters and writable attributes are checked, as other
|
|
# parameters are always passed indirectly, so do not impact calling
|
|
# conventions.
|
|
def typeNeedsBuiltinclass(type):
|
|
inner = type
|
|
while inner.kind == "typedef":
|
|
inner = inner.realtype
|
|
return (
|
|
inner.kind == "native"
|
|
and inner.specialtype is None
|
|
and inner.modifier is None
|
|
)
|
|
|
|
if methodOrAttribute.kind == "method":
|
|
for p in methodOrAttribute.params:
|
|
if p.paramtype == "in" and typeNeedsBuiltinclass(p.realtype):
|
|
raise IDLError(
|
|
(
|
|
"scriptable interface '%s' must be marked [builtinclass] "
|
|
"because it contains method '%s' with a by-value custom native "
|
|
"parameter '%s'"
|
|
)
|
|
% (iface.name, methodOrAttribute.name, p.name),
|
|
methodOrAttribute.location,
|
|
)
|
|
elif methodOrAttribute.kind == "attribute" and not methodOrAttribute.readonly:
|
|
if typeNeedsBuiltinclass(methodOrAttribute.realtype):
|
|
raise IDLError(
|
|
(
|
|
"scriptable interface '%s' must be marked [builtinclass] because it "
|
|
"contains writable attribute '%s' with a by-value custom native type"
|
|
)
|
|
% (iface.name, methodOrAttribute.name),
|
|
methodOrAttribute.location,
|
|
)
|
|
|
|
|
|
def ensureNoscriptIfNeeded(methodOrAttribute):
|
|
if not methodOrAttribute.isScriptable():
|
|
return
|
|
|
|
# NOTE: We can't check forward-declared interfaces to see if they're
|
|
# scriptable, as the information about whether they're scriptable is not
|
|
# known here.
|
|
def typeNeedsNoscript(type):
|
|
if type.kind in ["array", "legacyarray"]:
|
|
return typeNeedsNoscript(type.type)
|
|
if type.kind == "typedef":
|
|
return typeNeedsNoscript(type.realtype)
|
|
if type.kind == "native":
|
|
return type.specialtype is None
|
|
if type.kind == "interface":
|
|
return not type.attributes.scriptable
|
|
return False
|
|
|
|
if typeNeedsNoscript(methodOrAttribute.realtype):
|
|
raise IDLError(
|
|
"%s '%s' must be marked [noscript] because it has a non-scriptable type"
|
|
% (methodOrAttribute.kind, methodOrAttribute.name),
|
|
methodOrAttribute.location,
|
|
)
|
|
if methodOrAttribute.kind == "method":
|
|
for p in methodOrAttribute.params:
|
|
# iid_is arguments have their type ignored, so shouldn't be checked.
|
|
if not p.iid_is and typeNeedsNoscript(p.realtype):
|
|
raise IDLError(
|
|
(
|
|
"method '%s' must be marked [noscript] because it has a "
|
|
"non-scriptable parameter '%s'"
|
|
)
|
|
% (methodOrAttribute.name, p.name),
|
|
methodOrAttribute.location,
|
|
)
|
|
|
|
|
|
class Attribute(object):
|
|
kind = "attribute"
|
|
noscript = False
|
|
notxpcom = False
|
|
readonly = False
|
|
symbol = False
|
|
implicit_jscontext = False
|
|
nostdcall = False
|
|
must_use = False
|
|
binaryname = None
|
|
infallible = False
|
|
# explicit_setter_can_run_script is true if the attribute is explicitly
|
|
# annotated as having a setter that can cause script to run.
|
|
explicit_setter_can_run_script = False
|
|
# explicit_getter_can_run_script is true if the attribute is explicitly
|
|
# annotated as having a getter that can cause script to run.
|
|
explicit_getter_can_run_script = 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 value is not None:
|
|
raise IDLError("Unexpected attribute value", aloc)
|
|
|
|
if name == "noscript":
|
|
self.noscript = True
|
|
elif name == "notxpcom":
|
|
self.notxpcom = True
|
|
elif name == "symbol":
|
|
self.symbol = True
|
|
elif name == "implicit_jscontext":
|
|
self.implicit_jscontext = True
|
|
elif name == "nostdcall":
|
|
self.nostdcall = True
|
|
elif name == "must_use":
|
|
self.must_use = True
|
|
elif name == "infallible":
|
|
self.infallible = True
|
|
elif name == "can_run_script":
|
|
if (
|
|
self.explicit_setter_can_run_script
|
|
or self.explicit_getter_can_run_script
|
|
):
|
|
raise IDLError(
|
|
"Redundant getter_can_run_script or "
|
|
"setter_can_run_script annotation on "
|
|
"attribute",
|
|
aloc,
|
|
)
|
|
self.explicit_setter_can_run_script = True
|
|
self.explicit_getter_can_run_script = True
|
|
elif name == "setter_can_run_script":
|
|
if self.explicit_setter_can_run_script:
|
|
raise IDLError(
|
|
"Redundant setter_can_run_script annotation " "on attribute",
|
|
aloc,
|
|
)
|
|
self.explicit_setter_can_run_script = True
|
|
elif name == "getter_can_run_script":
|
|
if self.explicit_getter_can_run_script:
|
|
raise IDLError(
|
|
"Redundant getter_can_run_script annotation " "on attribute",
|
|
aloc,
|
|
)
|
|
self.explicit_getter_can_run_script = 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)
|
|
|
|
ensureInfallibleIsSound(self)
|
|
ensureBuiltinClassIfNeeded(self)
|
|
ensureNoscriptIfNeeded(self)
|
|
|
|
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 or self.notxpcom or self.nostdcall)
|
|
|
|
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
|
|
symbol = False
|
|
binaryname = None
|
|
implicit_jscontext = False
|
|
nostdcall = False
|
|
must_use = False
|
|
optional_argc = False
|
|
# explicit_can_run_script is true if the method is explicitly annotated
|
|
# as being able to cause script to run.
|
|
explicit_can_run_script = False
|
|
infallible = 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 == "symbol":
|
|
self.symbol = True
|
|
elif name == "implicit_jscontext":
|
|
self.implicit_jscontext = True
|
|
elif name == "optional_argc":
|
|
self.optional_argc = True
|
|
elif name == "nostdcall":
|
|
self.nostdcall = True
|
|
elif name == "must_use":
|
|
self.must_use = True
|
|
elif name == "can_run_script":
|
|
self.explicit_can_run_script = True
|
|
elif name == "infallible":
|
|
self.infallible = 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:
|
|
size_param = self.namemap.get(p.size_is, p.location)
|
|
if (
|
|
p.paramtype.count("in") == 1
|
|
and size_param.paramtype.count("in") == 0
|
|
):
|
|
raise IDLError(
|
|
"size_is parameter of an input must also be an input",
|
|
p.location,
|
|
)
|
|
if getBuiltinOrNativeTypeName(size_param.realtype) != "uint32_t":
|
|
raise IDLError(
|
|
"size_is parameter must have type 'uint32_t'",
|
|
p.location,
|
|
)
|
|
if p.iid_is:
|
|
iid_param = self.namemap.get(p.iid_is, p.location)
|
|
if (
|
|
p.paramtype.count("in") == 1
|
|
and iid_param.paramtype.count("in") == 0
|
|
):
|
|
raise IDLError(
|
|
"iid_is parameter of an input must also be an input",
|
|
p.location,
|
|
)
|
|
if getBuiltinOrNativeTypeName(iid_param.realtype) != "[nsid]":
|
|
raise IDLError(
|
|
"iid_is parameter must be an nsIID",
|
|
self.location,
|
|
)
|
|
|
|
ensureInfallibleIsSound(self)
|
|
ensureBuiltinClassIfNeeded(self)
|
|
ensureNoscriptIfNeeded(self)
|
|
|
|
def isScriptable(self):
|
|
if not self.iface.attributes.scriptable:
|
|
return False
|
|
return not (self.noscript or self.notxpcom or self.nostdcall)
|
|
|
|
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 == TypeId("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
|
|
default_value = 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 == "default":
|
|
if value is None:
|
|
raise IDLError("'default' must specify a default value", aloc)
|
|
self.default_value = 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 = LegacyArray(self.realtype)
|
|
|
|
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 as e:
|
|
raise IDLError(str(e), self.location)
|
|
except TypeError:
|
|
raise IDLError("Unexpected parameter attribute", self.location)
|
|
|
|
def rustType(self):
|
|
kwargs = {}
|
|
if self.shared:
|
|
kwargs["shared"] = True
|
|
if self.const:
|
|
kwargs["const"] = True
|
|
|
|
try:
|
|
return self.realtype.rustType(self.paramtype, **kwargs)
|
|
except IDLError as e:
|
|
raise IDLError(str(e), self.location)
|
|
except TypeError:
|
|
raise IDLError("Unexpected parameter attribute", self.location)
|
|
|
|
def toIDL(self):
|
|
return "%s%s %s %s" % (
|
|
paramAttlistToIDL(self.attlist),
|
|
self.paramtype,
|
|
self.type,
|
|
self.name,
|
|
)
|
|
|
|
def tsType(self):
|
|
# A generic retval param type needs special handling.
|
|
if self.retval and self.iid_is:
|
|
return "nsQIResult"
|
|
|
|
type = self.realtype.tsType()
|
|
if self.paramtype == "inout":
|
|
return f"InOutParam<{type}>"
|
|
if self.paramtype == "out":
|
|
return f"OutParam<{type}>"
|
|
return type
|
|
|
|
|
|
class LegacyArray(object):
|
|
kind = "legacyarray"
|
|
|
|
def __init__(self, basetype):
|
|
self.type = basetype
|
|
self.location = self.type.location
|
|
|
|
def nativeType(self, calltype, const=False):
|
|
if "element" in calltype:
|
|
raise IDLError("nested [array] unsupported", self.location)
|
|
|
|
# For legacy reasons, we have to add a 'const ' to builtin pointer array
|
|
# types. (`[array] in string` and `[array] in wstring` parameters)
|
|
if (
|
|
calltype == "in"
|
|
and isinstance(self.type, Builtin)
|
|
and self.type.isPointer()
|
|
):
|
|
const = True
|
|
|
|
return "%s%s*%s" % (
|
|
"const " if const else "",
|
|
self.type.nativeType("legacyelement"),
|
|
"*" if "out" in calltype else "",
|
|
)
|
|
|
|
def rustType(self, calltype, const=False):
|
|
return "%s%s%s" % (
|
|
"*mut " if "out" in calltype else "",
|
|
"*const " if const else "*mut ",
|
|
self.type.rustType("legacyelement"),
|
|
)
|
|
|
|
def tsType(self):
|
|
return self.type.tsType() + "[]"
|
|
|
|
|
|
class Array(object):
|
|
kind = "array"
|
|
|
|
def __init__(self, type, location):
|
|
self.type = type
|
|
self.location = location
|
|
|
|
@property
|
|
def name(self):
|
|
return "Array<%s>" % self.type.name
|
|
|
|
def resolve(self, idl):
|
|
idl.getName(self.type, self.location)
|
|
|
|
def nativeType(self, calltype):
|
|
if calltype == "legacyelement":
|
|
raise IDLError("[array] Array<T> is unsupported", self.location)
|
|
|
|
base = "nsTArray<%s>" % self.type.nativeType("element")
|
|
if "out" in calltype:
|
|
return "%s& " % base
|
|
elif "in" == calltype:
|
|
return "const %s& " % base
|
|
else:
|
|
return base
|
|
|
|
def rustType(self, calltype):
|
|
if calltype == "legacyelement":
|
|
raise IDLError("[array] Array<T> is unsupported", self.location)
|
|
|
|
base = "thin_vec::ThinVec<%s>" % self.type.rustType("element")
|
|
if "out" in calltype:
|
|
return "*mut %s" % base
|
|
elif "in" == calltype:
|
|
return "*const %s" % base
|
|
else:
|
|
return base
|
|
|
|
def tsType(self):
|
|
return self.type.tsType() + "[]"
|
|
|
|
|
|
TypeId = namedtuple("TypeId", "name params")
|
|
|
|
|
|
# Make str(TypeId) produce a nicer value
|
|
TypeId.__str__ = lambda self: (
|
|
"%s<%s>" % (self.name, ", ".join(str(p) for p in self.params))
|
|
if self.params is not None
|
|
else self.name
|
|
)
|
|
|
|
|
|
# Allow skipping 'params' in TypeId(..)
|
|
TypeId.__new__.__defaults__ = (None,)
|
|
|
|
|
|
class IDLParser(object):
|
|
keywords = {
|
|
"cenum": "CENUM",
|
|
"const": "CONST",
|
|
"interface": "INTERFACE",
|
|
"in": "IN",
|
|
"inout": "INOUT",
|
|
"out": "OUT",
|
|
"attribute": "ATTRIBUTE",
|
|
"raises": "RAISES",
|
|
"readonly": "READONLY",
|
|
"native": "NATIVE",
|
|
"typedef": "TYPEDEF",
|
|
"webidl": "WEBIDL",
|
|
}
|
|
|
|
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"/\*(\n|.)*?\*/"
|
|
t.lexer.lineno += t.value.count("\n")
|
|
if t.value.startswith("/**"):
|
|
self._doccomments.append(t.value)
|
|
|
|
def t_singlelinecomment(self, t):
|
|
r"//[^\n]*"
|
|
|
|
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]*" # NOQA: E501
|
|
t.type = self.keywords.get(t.value, "IDENTIFIER")
|
|
return t
|
|
|
|
def t_LCDATA(self, t):
|
|
r"%\{[ ]*C\+\+[ ]*\n(?P<cdata>(\n|.)*?\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):
|
|
# Matches non-parenthesis characters, or a single open and closing
|
|
# parenthesis with at least one non-parenthesis character before,
|
|
# between and after them (for compatibility with std::function).
|
|
r"[^()\n]+(?:\([^()\n]+\)[^()\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
|
|
| webidl productions"""
|
|
p[0] = list(p[2])
|
|
p[0].insert(0, p[1])
|
|
|
|
def p_typedef(self, p):
|
|
"""typedef : attributes TYPEDEF type IDENTIFIER ';'"""
|
|
p[0] = Typedef(
|
|
type=p[3],
|
|
name=p[4],
|
|
attlist=p[1]["attlist"],
|
|
location=self.getLocation(p, 2),
|
|
doccomments=getattr(p[1], "doccomments", []) + p.slice[2].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_webidl(self, p):
|
|
"""webidl : WEBIDL IDENTIFIER ';'"""
|
|
p[0] = WebIDL(name=p[2], location=self.getLocation(p, 2))
|
|
|
|
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)
|
|
|
|
def loc():
|
|
return 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", loc()
|
|
)
|
|
|
|
if base is not None:
|
|
raise IDLError("Forward-declared interface must not have a base", loc())
|
|
p[0] = Forward(name=name, location=loc(), doccomments=doccomments)
|
|
else:
|
|
p[0] = Interface(
|
|
name=name,
|
|
attlist=attlist,
|
|
base=base,
|
|
members=body,
|
|
location=loc(),
|
|
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 type 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_cenum(self, p):
|
|
"""member : CENUM IDENTIFIER ':' NUMBER '{' variants '}' ';'"""
|
|
p[0] = CEnum(
|
|
name=p[2],
|
|
width=int(p[4]),
|
|
variants=p[6],
|
|
location=self.getLocation(p, 1),
|
|
doccomments=p.slice[1].doccomments,
|
|
)
|
|
|
|
def p_variants_start(self, p):
|
|
"""variants :"""
|
|
p[0] = []
|
|
|
|
def p_variants_single(self, p):
|
|
"""variants : variant"""
|
|
p[0] = [p[1]]
|
|
|
|
def p_variants_continue(self, p):
|
|
"""variants : variant ',' variants"""
|
|
p[0] = [p[1]] + p[3]
|
|
|
|
def p_variant_implicit(self, p):
|
|
"""variant : IDENTIFIER"""
|
|
p[0] = CEnumVariant(p[1], None, self.getLocation(p, 1))
|
|
|
|
def p_variant_explicit(self, p):
|
|
"""variant : IDENTIFIER '=' number"""
|
|
p[0] = CEnumVariant(p[1], p[3], self.getLocation(p, 1))
|
|
|
|
def p_member_att(self, p):
|
|
"""member : attributes optreadonly ATTRIBUTE type 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 type 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 type IDENTIFIER"""
|
|
p[0] = Param(
|
|
paramtype=p[2],
|
|
type=p[3],
|
|
name=p[4],
|
|
attlist=p[1]["attlist"],
|
|
location=self.getLocation(p, 4),
|
|
)
|
|
|
|
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_type_id(self, p):
|
|
"""type : IDENTIFIER"""
|
|
p[0] = TypeId(name=p[1])
|
|
p.slice[0].doccomments = p.slice[1].doccomments
|
|
|
|
def p_type_generic(self, p):
|
|
"""type : IDENTIFIER '<' typelist '>'"""
|
|
p[0] = TypeId(name=p[1], params=p[3])
|
|
p.slice[0].doccomments = p.slice[1].doccomments
|
|
|
|
def p_typelist(self, p):
|
|
"""typelist : type"""
|
|
p[0] = [p[1]]
|
|
|
|
def p_typelist_continue(self, p):
|
|
"""typelist : type ',' typelist"""
|
|
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):
|
|
self._doccomments = []
|
|
self.lexer = lex.lex(object=self, debug=False)
|
|
self.parser = yacc.yacc(module=self, write_tables=False, debug=False)
|
|
|
|
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, encoding="utf-8").read(), filename=f)
|