584 lines
18 KiB
JavaScript
584 lines
18 KiB
JavaScript
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.1 (the "License"); you may not use this file except in
|
|
* compliance with the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 2002
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
/* The nsInterfaceInfoToIDL implementation.*/
|
|
|
|
|
|
/***************************************************************************/
|
|
// nsInterfaceInfoToIDL part...
|
|
|
|
const IInfo = new Components.Constructor("@mozilla.org/scriptableInterfaceInfo;1",
|
|
"nsIScriptableInterfaceInfo",
|
|
"init");
|
|
|
|
const nsIDataType = Components.interfaces.nsIDataType;
|
|
const nsISupports = Components.interfaces.nsISupports;
|
|
|
|
const PARAM_NAME_PREFIX = "arg";
|
|
const MISSING_INTERFACE = "@"; // flag to indicate missing interfaceinfo
|
|
|
|
// helpers...
|
|
|
|
/********************************************************/
|
|
// accumulate a string with a stream-ish abstraction
|
|
|
|
function Buffer() {
|
|
this.buffer = "";
|
|
}
|
|
|
|
Buffer.prototype = {
|
|
write : function(s) {
|
|
if(s)
|
|
this.buffer += s;
|
|
},
|
|
|
|
writeln : function(s) {
|
|
if(s)
|
|
this.buffer += s + "\n";
|
|
else
|
|
this.buffer += "\n";
|
|
}
|
|
}
|
|
|
|
/********************************************************/
|
|
|
|
/**
|
|
* takes: {xxx}
|
|
* returns: uuid(xxx)
|
|
*/
|
|
function formatID(str)
|
|
{
|
|
return "uuid("+str.substring(1,str.length-1)+")";
|
|
}
|
|
|
|
function formatConstType(type)
|
|
{
|
|
switch(type)
|
|
{
|
|
case nsIDataType.VTYPE_INT16:
|
|
return "PRInt16";
|
|
case nsIDataType.VTYPE_INT32:
|
|
return "PRInt32";
|
|
case nsIDataType.VTYPE_UINT16:
|
|
return "PRUint16";
|
|
case nsIDataType.VTYPE_UINT32:
|
|
return "PRUint32";
|
|
default:
|
|
return "!!!! bad const type !!!";
|
|
}
|
|
}
|
|
|
|
function formatTypeName(info, methodIndex, param, dimension)
|
|
{
|
|
var type = info.getTypeForParam(methodIndex, param, dimension);
|
|
|
|
switch(type.dataType)
|
|
{
|
|
case nsIDataType.VTYPE_INT8 :
|
|
return "PRInt8";
|
|
case nsIDataType.VTYPE_INT16:
|
|
return "PRInt16";
|
|
case nsIDataType.VTYPE_INT32:
|
|
return "PRInt32";
|
|
case nsIDataType.VTYPE_INT64:
|
|
return "PRInt64";
|
|
case nsIDataType.VTYPE_UINT8:
|
|
return "PRUint8";
|
|
case nsIDataType.VTYPE_UINT16:
|
|
return "PRUint16";
|
|
case nsIDataType.VTYPE_UINT32:
|
|
return "PRUint32";
|
|
case nsIDataType.VTYPE_UINT64:
|
|
return "PRUint64";
|
|
case nsIDataType.VTYPE_FLOAT:
|
|
return "float";
|
|
case nsIDataType.VTYPE_DOUBLE:
|
|
return "double";
|
|
case nsIDataType.VTYPE_BOOL:
|
|
return "PRBool";
|
|
case nsIDataType.VTYPE_CHAR:
|
|
return "char";
|
|
case nsIDataType.VTYPE_WCHAR:
|
|
return "PRUnichar";
|
|
case nsIDataType.VTYPE_VOID:
|
|
if(type.isPointer)
|
|
return "voidPtr";
|
|
return "void";
|
|
case nsIDataType.VTYPE_ID:
|
|
// order matters here...
|
|
if(type.isReference)
|
|
return "nsIDRef";
|
|
if(type.isPointer)
|
|
return "nsIDPtr";
|
|
return "nsID";
|
|
case nsIDataType.VTYPE_ASTRING:
|
|
return "aString";
|
|
case nsIDataType.VTYPE_CHAR_STR:
|
|
return "string";
|
|
case nsIDataType.VTYPE_WCHAR_STR:
|
|
return "wstring";
|
|
case nsIDataType.VTYPE_INTERFACE:
|
|
try {
|
|
return info.getInfoForParam(methodIndex, param).name;
|
|
} catch(e) {
|
|
return "/*!!! missing interface info, guessing!!!*/ nsISupports";
|
|
}
|
|
case nsIDataType.VTYPE_INTERFACE_IS:
|
|
return "nsQIResult";
|
|
case nsIDataType.VTYPE_ARRAY:
|
|
return formatTypeName(info, methodIndex, param, dimension+1);
|
|
case nsIDataType.VTYPE_STRING_SIZE_IS:
|
|
return "string";
|
|
case nsIDataType.VTYPE_WSTRING_SIZE_IS:
|
|
return "wstring";
|
|
default:
|
|
return "!!!! bad data type !!!";
|
|
}
|
|
}
|
|
|
|
function formatBracketForParam(info, methodIndex, param)
|
|
{
|
|
var type = param.type;
|
|
var str = "[";
|
|
var found = 0;
|
|
var size_is_ArgNum;
|
|
var length_is_ArgNum;
|
|
|
|
if(param.isRetval)
|
|
{
|
|
if(found++)
|
|
str += ", ";
|
|
str += "retval"
|
|
}
|
|
|
|
if(param.isShared)
|
|
{
|
|
if(found++)
|
|
str += ", ";
|
|
str += "shared"
|
|
}
|
|
|
|
if(type.isArray)
|
|
{
|
|
if(found++)
|
|
str += ", ";
|
|
str += "array"
|
|
}
|
|
|
|
if(type.dataType == nsIDataType.VTYPE_INTERFACE_IS)
|
|
{
|
|
if(found++)
|
|
str += ", ";
|
|
str += "iid_is("+
|
|
PARAM_NAME_PREFIX +
|
|
info.getInterfaceIsArgNumberForParam(methodIndex, param) + ")";
|
|
}
|
|
|
|
if(type.isArray ||
|
|
type.dataType == nsIDataType.VTYPE_STRING_SIZE_IS ||
|
|
type.dataType == nsIDataType.VTYPE_WSTRING_SIZE_IS)
|
|
{
|
|
if(found++)
|
|
str += ", ";
|
|
|
|
size_is_ArgNum =
|
|
info.getSizeIsArgNumberForParam(methodIndex, param, 0);
|
|
|
|
str += "size_is("+ PARAM_NAME_PREFIX + size_is_ArgNum + ")";
|
|
|
|
length_is_ArgNum =
|
|
info.getLengthIsArgNumberForParam(methodIndex, param, 0);
|
|
|
|
if(length_is_ArgNum != size_is_ArgNum)
|
|
{
|
|
str += ", ";
|
|
str += "length_is("+ PARAM_NAME_PREFIX + length_is_ArgNum + ")";
|
|
}
|
|
}
|
|
|
|
if(!found)
|
|
return "";
|
|
str += "] ";
|
|
return str
|
|
}
|
|
|
|
function doInterface(out, iid)
|
|
{
|
|
var i, k, t, m, m2, c, p, readonly, bracketed, paramCount, retvalTypeName;
|
|
|
|
var info = new IInfo(iid);
|
|
var parent = info.parent;
|
|
|
|
var constBaseIndex = parent ? parent.constantCount : 0;
|
|
var constTotalCount = info.constantCount;
|
|
var constLocalCount = constTotalCount - constBaseIndex;
|
|
|
|
var methodBaseIndex = parent ? parent.methodCount : 0;
|
|
var methodTotalCount = info.methodCount;
|
|
var methodLocalCount = methodTotalCount - methodBaseIndex;
|
|
|
|
|
|
// maybe recurring to emit parent declarations is not a good idea...
|
|
// if(parent)
|
|
// doInterface(parent.interfaceID);
|
|
|
|
out.writeln();
|
|
|
|
// comment out nsISupports
|
|
// if(iid.equals(nsISupports))
|
|
// out.writeln("/*\n");
|
|
|
|
out.writeln("[" + (info.isScriptable ? "scriptable, " : "") +
|
|
formatID(info.interfaceID.number) + "]");
|
|
|
|
out.writeln("interface "+ info.name +
|
|
(parent ? (" : "+parent.name) : "") + " {");
|
|
|
|
if(constLocalCount)
|
|
{
|
|
for(i = constBaseIndex; i < constTotalCount; i++)
|
|
{
|
|
c = info.getConstant(i);
|
|
out.writeln(" const " + formatConstType(c.type.dataType) + " " +
|
|
c.name + " = " + c.value + ";");
|
|
}
|
|
}
|
|
|
|
if(constLocalCount && methodLocalCount)
|
|
out.writeln();
|
|
|
|
if(methodLocalCount)
|
|
{
|
|
for(i = methodBaseIndex; i < methodTotalCount; i++)
|
|
{
|
|
m = info.getMethodInfo(i);
|
|
|
|
if(m.isNotXPCOM)
|
|
bracketed = "[notxpcom] "
|
|
else if(m.isHidden)
|
|
bracketed = "[noscript] "
|
|
else
|
|
bracketed = "";
|
|
|
|
if(m.isGetter)
|
|
{
|
|
// Is an attribute
|
|
|
|
// figure out if this is readonly
|
|
m2 = i+1 < methodTotalCount ? info.getMethodInfo(i+1) : null;
|
|
readonly = !m2 || m2.name != m.name;
|
|
|
|
out.writeln(" " + bracketed + (readonly ? "readonly " : "") +
|
|
"attribute " +
|
|
formatTypeName(info, i, m.getParam(0), 0) +
|
|
" " + m.name + ";\n");
|
|
|
|
if(!readonly)
|
|
i++; // skip the next one, we have it covered.
|
|
|
|
continue;
|
|
}
|
|
// else...
|
|
|
|
paramCount = m.paramCount;
|
|
|
|
// 'last' param is used to figure out retvalTypeName
|
|
|
|
p = paramCount ? m.getParam(paramCount-1) : null;
|
|
|
|
if(m.isNotXPCOM)
|
|
retvalTypeName = formatTypeName(info, i, m.result, 0);
|
|
else if(p && "[retval] " == formatBracketForParam(info, i, p))
|
|
{
|
|
// Check for the exact string above because anything else
|
|
// indicates that there either is no expilict retval
|
|
// or there are additional braketed attributes (meaning that
|
|
// the retval must appear in the param list and not
|
|
// preceeding the method name).
|
|
retvalTypeName = formatTypeName(info, i, p, 0);
|
|
// no need to print it in the param list
|
|
paramCount-- ;
|
|
}
|
|
else
|
|
retvalTypeName = "void";
|
|
|
|
// print method name
|
|
|
|
out.writeln(" " + bracketed + retvalTypeName + " " + m.name +
|
|
"(" + (paramCount ? "" : ");"));
|
|
|
|
// print params
|
|
|
|
for(k = 0; k < paramCount; k++)
|
|
{
|
|
p = m.getParam(k);
|
|
out.writeln(" "+
|
|
formatBracketForParam(info, i, p) +
|
|
(p.isOut ? p.isIn ? "inout " : "out " : "in ") +
|
|
formatTypeName(info, i, p, 0) + " " +
|
|
PARAM_NAME_PREFIX+k +
|
|
(k+1 == paramCount ? ");\n" : ", "));
|
|
}
|
|
}
|
|
}
|
|
|
|
out.writeln("};\n");
|
|
|
|
// comment out nsISupports
|
|
// if(iid.equals(nsISupports))
|
|
// out.writeln("\n*/\n");
|
|
}
|
|
|
|
function appendForwardDeclarations(list, info)
|
|
{
|
|
list.push(info.name);
|
|
if(info.parent)
|
|
appendForwardDeclarations(list, info.parent);
|
|
|
|
var i, k, m, p;
|
|
|
|
for(i = 0; i < info.methodCount; i++)
|
|
{
|
|
m = info.getMethodInfo(i);
|
|
|
|
for(k = 0; k < m.paramCount; k++)
|
|
{
|
|
p = m.getParam(k);
|
|
|
|
if(p.type.dataType == nsIDataType.VTYPE_INTERFACE)
|
|
{
|
|
var name;
|
|
try {
|
|
name = info.getInfoForParam(i, p).name;
|
|
} catch(e) {
|
|
name = MISSING_INTERFACE;
|
|
}
|
|
list.push(name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function doForwardDeclarations(out, iid)
|
|
{
|
|
var i, cur, prev;
|
|
var list = [];
|
|
appendForwardDeclarations(list, new IInfo(iid));
|
|
list.sort();
|
|
|
|
out.writeln("// forward declarations...");
|
|
|
|
for(i = 0; i < list.length; i++)
|
|
{
|
|
cur = list[i];
|
|
if(cur != prev && cur != "nsISupports")
|
|
{
|
|
if(cur == MISSING_INTERFACE)
|
|
out.writeln("/*\n * !!! Unable to find details for a declared "+
|
|
"interface (name unknown)!!!\n */");
|
|
else
|
|
out.writeln("interface " + cur +";");
|
|
prev = cur;
|
|
}
|
|
}
|
|
}
|
|
|
|
function buildForwardDeclarationsList(iid)
|
|
{
|
|
var i, cur, prev;
|
|
var list = [];
|
|
var outList = [];
|
|
appendForwardDeclarations(list, new IInfo(iid));
|
|
list.sort();
|
|
|
|
for(i = 0; i < list.length; i++)
|
|
{
|
|
cur = list[i];
|
|
if(cur != prev && cur != "nsISupports")
|
|
{
|
|
if(cur != MISSING_INTERFACE)
|
|
outList.push(cur);
|
|
prev = cur;
|
|
}
|
|
}
|
|
return outList;
|
|
}
|
|
|
|
/*********************************************************/
|
|
|
|
/* Our Componenent ctor */
|
|
function nsInterfaceInfoToIDL() {}
|
|
|
|
/* decorate prototype to provide ``class'' methods and property accessors */
|
|
nsInterfaceInfoToIDL.prototype =
|
|
{
|
|
// nsIInterfaceInfoToIDL methods...
|
|
|
|
// string generateIDL(in nsIIDRef aIID,
|
|
// in PRBool withIncludes,
|
|
// in PRBool withForwardDeclarations);
|
|
generateIDL : function(aIID, withIncludes, withForwardDeclarations) {
|
|
var out = new Buffer;
|
|
out.writeln();
|
|
|
|
if(withIncludes)
|
|
{
|
|
out.writeln('#include "nsISupports.idl"');
|
|
out.writeln();
|
|
}
|
|
|
|
if(withForwardDeclarations)
|
|
{
|
|
doForwardDeclarations(out, aIID);
|
|
out.writeln("");
|
|
}
|
|
|
|
doInterface(out, aIID);
|
|
|
|
return out.buffer;
|
|
},
|
|
|
|
// void getReferencedInterfaceNames(in nsIIDRef aIID,
|
|
// out PRUint32 aArrayLength,
|
|
// [retval, array, size_is(aArrayLength)]
|
|
// out string aNames);
|
|
|
|
getReferencedInterfaceNames : function(aIID, aArrayLength) {
|
|
var list = buildForwardDeclarationsList(aIID);
|
|
aArrayLength.value = list.length;
|
|
return list;
|
|
},
|
|
|
|
// nsISupports methods...
|
|
QueryInterface: function (iid) {
|
|
if (!iid.equals(Components.interfaces.nsIInterfaceInfoToIDL) &&
|
|
!iid.equals(Components.interfaces.nsISupports)) {
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
}
|
|
return this;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|
|
/***************************************************************************/
|
|
// parts specific to my use of the the generic module code...
|
|
|
|
const MODULE_NAME = "nsInterfaceInfoToIDL";
|
|
const MODULE_CONTRACT_ID = "@mozilla.org/interfaceinfotoidl;1";
|
|
const MODULE_CID = "{47d98974-a1b7-46a6-bc99-8abc374bba3f}";
|
|
const MODULE_CTOR = nsInterfaceInfoToIDL;
|
|
|
|
/***************************************************************************/
|
|
/***************************************************************************/
|
|
// generic nsIModule part...
|
|
|
|
function NSGetModule(compMgr, fileSpec) {
|
|
return new GenericModule(MODULE_NAME, MODULE_CONTRACT_ID,
|
|
MODULE_CID, MODULE_CTOR);
|
|
}
|
|
|
|
function GenericModule (name, contractID, CID, ctor) {
|
|
this.name = name;
|
|
this.contractID = contractID;
|
|
this.CID = Components.ID(CID);
|
|
this.ctor = ctor;
|
|
}
|
|
|
|
GenericModule.prototype = {
|
|
/*
|
|
* RegisterSelf is called at registration time (component installation
|
|
* or the only-until-release startup autoregistration) and is responsible
|
|
* for notifying the component manager of all components implemented in
|
|
* this module. The fileSpec, location and type parameters are mostly
|
|
* opaque, and should be passed on to the registerComponent call
|
|
* unmolested.
|
|
*/
|
|
registerSelf: function (compMgr, fileSpec, location, type) {
|
|
compMgr = compMgr.QueryInterface(Components.interfaces.nsIComponentRegistrar);
|
|
compMgr.registerFactoryLocation(this.CID, this.name, this.contractID,
|
|
fileSpec, location, type);
|
|
},
|
|
|
|
/*
|
|
* The GetClassObject method is responsible for producing Factory and
|
|
* SingletonFactory objects (the latter are specialized for services).
|
|
*/
|
|
getClassObject: function (compMgr, cid, iid) {
|
|
if (!cid.equals(this.CID))
|
|
throw Components.results.NS_ERROR_NO_INTERFACE;
|
|
|
|
if (!iid.equals(Components.interfaces.nsIFactory))
|
|
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
|
|
|
|
this.myFactory.ctor = this.ctor;
|
|
return this.myFactory;
|
|
},
|
|
|
|
/* factory object */
|
|
myFactory: {
|
|
|
|
/*
|
|
* Construct an instance of the interface specified by iid, possibly
|
|
* aggregating it with the provided outer. (If you don't know what
|
|
* aggregation is all about, you don't need to. It reduces even the
|
|
* mightiest of XPCOM warriors to snivelling cowards.)
|
|
*/
|
|
createInstance: function (outer, iid) {
|
|
if (outer != null)
|
|
throw Components.results.NS_ERROR_NO_AGGREGATION;
|
|
return (new this.ctor()).QueryInterface(iid);
|
|
}
|
|
},
|
|
|
|
/*
|
|
* The canUnload method signals that the component is about to be unloaded.
|
|
* C++ components can return false to indicate that they don't wish to be
|
|
* unloaded, but the return value from JS components' canUnload is ignored:
|
|
* mark-and-sweep will keep everything around until it's no longer in use,
|
|
* making unconditional ``unload'' safe.
|
|
*
|
|
* You still need to provide a (likely useless) canUnload method, though:
|
|
* it's part of the nsIModule interface contract, and the JS loader _will_
|
|
* call it.
|
|
*/
|
|
canUnload: function(compMgr) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************/
|