The Tor Browser: comparison xpcom/analysis/type-printer.js

comparison: xpcom/analysis/type-printer.js

xpcom/analysis/type-printer.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:0a8e049bcd3c
+/* 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/. */
+let dumpTypes = options['dump-types'].split(',');
+let interestingList = {};
+let typelist = {};
+function interestingType(t)
+{
+let name = t.name;
+if (dumpTypes.some(function(n) n == name)) {
+interestingList[name] = t;
+typelist[name] = t;
+return true;
+}
+for each (let base in t.bases) {
+if (base.access == 'public' && interestingType(base.type)) {
+typelist[name] = t;
+return true;
+}
+}
+return false;
+}
+function addSubtype(t, subt)
+{
+if (subt.typedef === undefined &&
+subt.kind === undefined)
+throw Error("Unexpected subtype: not class or typedef: " + subt);
+if (t.subtypes === undefined)
+t.subtypes = [];
+t.subtypes.push(subt);
+}
+function process_type(t)
+{
+interestingType(t);
+for each (let base in t.bases)
+addSubtype(base.type, t);
+}
+function process_decl(d)
+{
+if (d.typedef !== undefined && d.memberOf)
+addSubtype(d.memberOf, d);
+}
+function publicBases(t)
+{
+yield t;
+for each (let base in t.bases)
+if (base.access == "public")
+for each (let gbase in publicBases(base.type))
+yield gbase;
+}
+function publicMembers(t)
+{
+for each (let base in publicBases(t)) {
+for each (let member in base.members) {
+if (member.access === undefined)
+throw Error("Harumph: member without access? " + member);
+if (member.access != "public")
+continue;
+yield member;
+}
+}
+}
+/**
+* Get the short name of a decl name. E.g. turn
+* "MyNamespace::MyClass::Method(int j) const" into
+* "Method"
+*/
+function getShortName(decl)
+{
+let name = decl.name;
+let lp = name.lastIndexOf('(');
+if (lp != -1)
+name = name.slice(0, lp);
+lp = name.lastIndexOf('::');
+if (lp != -1)
+name = name.slice(lp + 2);
+return name;
+}
+/**
+* Remove functions in a base class which were overridden in a derived
+* class.
+*
+* Although really, we should perhaps do this the other way around, or even
+* group the two together, but that can come later.
+*/
+function removeOverrides(members)
+{
+let overrideMap = {};
+for (let i = members.length - 1; i >= 0; --i) {
+let m = members[i];
+if (!m.isFunction)
+continue;
+let shortName = getShortName(m);
+let overrides = overrideMap[shortName];
+if (overrides === undefined) {
+overrideMap[shortName] = [m];
+continue;
+}
+let found = false;
+for each (let override in overrides) {
+if (signaturesMatch(override, m)) {
+// remove members[i], it was overridden
+members.splice(i, 1);
+found = true;
+}
+}
+if (found)
+continue;
+overrides.push(m);
+}
+}
+/**
+* Generates the starting position of lines within a file.
+*/
+function getLineLocations(fdata)
+{
+yield 0;
+let r = /\n/y;
+let pos = 0;
+let i = 1;
+for (;;) {
+pos = fdata.indexOf('\n', pos) + 1;
+if (pos == 0)
+break;
+yield pos;
+i++;
+}
+}
+/**
+* Find and return the doxygen comment immediately prior to the location
+* object that was passed in.
+*
+* @todo: parse doccomment data such as @param, @returns
+* @todo: parse comments for markup
+*/
+function getDocComment(loc)
+{
+let fdata = read_file(loc.file);
+let linemap = [l for (l in getLineLocations(fdata))];
+if (loc.line >= linemap.length) {
+warning("Location larger than actual header: " + loc);
+return <></>;
+}
+let endpos = linemap[loc.line - 1] + loc.column - 1;
+let semipos = fdata.lastIndexOf(';', endpos);
+let bracepos = fdata.lastIndexOf('}', endpos);
+let searchslice = fdata.slice(Math.max(semipos, bracepos) + 1, endpos);
+let m = searchslice.match(/\/\*\*[\s\S]*?\*\//gm);
+if (m === null)
+return <></>;
+let dc = m[m.length - 1].slice(3, -2);
+dc = dc.replace(/^\s*(\*+[ \t]*)?/gm, "");
+return <pre class="doccomment">{dc}</pre>;
+}
+function typeName(t)
+{
+if (t.name !== undefined)
+return t.name;
+if (t.isPointer)
+return "%s%s*".format(t.isConst ? "const " : "", typeName(t.type));
+if (t.isReference)
+return "%s%s&".format(t.isConst ? "const " : "", typeName(t.type));
+return t.toString();
+}
+function publicBaseList(t)
+{
+let l = <ul/>;
+for each (let b in t.bases) {
+if (b.access == 'public')
+l.* += <li><a href={"/en/%s".format(b.type.name)}>{b.type.name}</a></li>;
+}
+if (l.*.length() == 0)
+return <></>;
+return <>
+<h2>Base Classes</h2>
+{l}
+</>;
+}
+/**
+* Get a source-link for a given location.
+*/
+function getLocLink(loc, text)
+{
+return <a class="loc"
+href={"http://hg.mozilla.org/mozilla-central/file/%s/[LOC%s]#l%i".format(options.rev, loc.file, loc.line)}>{text}</a>;
+}
+function dumpType(t)
+{
+print("DUMP-TYPE(%s)".format(t.name));
+let methodOverview = <tbody />;
+let methodList = <div/>;
+let memberList = <></>;
+let shortNameMap = {};
+let members = [m for (m in publicMembers(t))];
+removeOverrides(members);
+for each (let m in members) {
+let qname = m.memberOf.name + '::';
+// we don't inherit constructors from base classes
+if (m.isConstructor && m.memberOf !== t)
+continue;
+if (m.name.indexOf(qname) != 0)
+throw Error("Member name not qualified?");
+let name = m.name.slice(qname.length);
+if (name.indexOf('~') == 0)
+continue;
+if (m.isFunction) {
+let innerList;
+let shortName = getShortName(m);
+if (m.isConstructor)
+shortName = 'Constructors';
+if (shortNameMap.hasOwnProperty(shortName)) {
+innerList = shortNameMap[shortName];
+}
+else {
+let overview =
+<tr><td>
+<a href={'#%s'.format(escape(shortName))}>{shortName}</a>
+</td></tr>;
+if (m.isConstructor)
+methodOverview.insertChildAfter(null, overview);
+else
+methodOverview.appendChild(overview);
+let shortMarkup =
+<div>
+<h3 id={shortName}>{shortName}</h3>
+<dl/>
+</div>;
+if (m.isConstructor)
+methodList.insertChildAfter(null, shortMarkup);
+else
+methodList.appendChild(shortMarkup);
+innerList = shortMarkup.dl;
+shortNameMap[shortName] = innerList;
+}
+let parameters = <ul/>;
+for each (p in m.parameters) {
+let name = p.name;
+if (name == 'this')
+continue;
+if (/^D_\d+$/.test(name))
+name = '<anonymous>';
+parameters.* += <li>{typeName(p.type)} {name}</li>;
+}
+innerList.* +=
+<>
+<dt id={name} class="methodName">
+<code>{typeName(m.type.type)} {name}</code> - {getLocLink(m.loc, "source")}
+</dt>
+<dd>
+{getDocComment(m.loc)}
+{parameters.*.length() > 0 ?
+<>
+<h4>Parameters</h4>
+{parameters}
+</> : <></>}
+</dd>
+</>;
+}
+else {
+memberList += <li class="member">{name}</li>;
+}
+}
+let r =
+<body>
+<p>{getLocLink(t.loc, "Class Declaration")}</p>
+{getDocComment(t.loc)}
+{dumpTypes.some(function(n) n == t.name) ?
+<>
+[MAP{t.name}-graph.map]
+<img src={"/@api/deki/pages/=en%%252F%s/files/=%s-graph.png".format(t.name, t.name)} usemap="#classes" />
+</> : <></>
+}
+{methodOverview.*.length() > 0 ?
+<>
+<h2>Method Overview</h2>
+<table class="standard-table">{methodOverview}</table>
+</> :
+""
+}
+{publicBaseList(t)}
+<h2>Data Members</h2>
+{memberList.*.length() > 0 ?
+memberList :
+<p><em>No public members.</em></p>
+}
+<h2>Methods</h2>
+{methodList.*.length() > 0 ?
+methodList :
+<p><em>No public methods.</em></p>
+}
+</body>;
+write_file(t.name + ".html", r.toXMLString());
+}
+function graphType(t)
+{
+print("GRAPH-TYPE(%s)".format(t.name));
+let contents = "digraph classes {\n"
++ "  node [shape=rectangle fontsize=11]\n"
++ "  %s;\n".format(t.name);
+function graphClass(c)
+{
+contents += '%s [URL="http://developer.mozilla.org/en/%s"]\n'.format(c.name, c.name);
+for each (let st in c.subtypes) {
+contents += "  %s -> %s;\n".format(c.name, st.name);
+graphClass(st);
+}
+}
+graphClass(t);
+contents += "}\n";
+write_file(t.name + "-graph.gv", contents);
+}
+function input_end()
+{
+for (let p in typelist)
+dumpType(typelist[p]);
+for (let n in interestingList)
+graphType(interestingList[n]);
+}