solidity/libsolidity/interface/InterfaceHandler.cpp

190 lines
5.6 KiB
C++
Raw Normal View History

2015-10-20 22:21:52 +00:00
#include <libsolidity/interface/InterfaceHandler.h>
2015-10-06 11:01:55 +00:00
#include <boost/range/irange.hpp>
2015-10-20 22:21:52 +00:00
#include <libsolidity/ast/AST.h>
#include <libsolidity/interface/CompilerStack.h>
2015-10-26 14:13:36 +00:00
using namespace std;
using namespace dev;
using namespace dev::solidity;
Json::Value InterfaceHandler::documentation(
2015-06-09 11:20:42 +00:00
ContractDefinition const& _contractDef,
DocumentationType _type
)
{
switch(_type)
{
2015-02-09 13:12:36 +00:00
case DocumentationType::NatspecUser:
2015-07-16 13:57:57 +00:00
return userDocumentation(_contractDef);
2015-02-09 13:12:36 +00:00
case DocumentationType::NatspecDev:
2015-07-16 13:57:57 +00:00
return devDocumentation(_contractDef);
2015-02-09 13:12:36 +00:00
case DocumentationType::ABIInterface:
return abiInterface(_contractDef);
}
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation type"));
}
Json::Value InterfaceHandler::abiInterface(ContractDefinition const& _contractDef)
{
Json::Value abi(Json::arrayValue);
2015-04-17 13:26:12 +00:00
2015-04-22 15:00:22 +00:00
auto populateParameters = [](vector<string> const& _paramNames, vector<string> const& _paramTypes)
2015-04-17 13:26:12 +00:00
{
2015-04-22 15:00:22 +00:00
Json::Value params(Json::arrayValue);
solAssert(_paramNames.size() == _paramTypes.size(), "Names and types vector size does not match");
for (unsigned i = 0; i < _paramNames.size(); ++i)
{
Json::Value param;
param["name"] = _paramNames[i];
param["type"] = _paramTypes[i];
params.append(param);
}
return params;
};
2015-04-17 13:26:12 +00:00
2015-08-31 16:44:29 +00:00
for (auto it: _contractDef.interfaceFunctions())
{
auto externalFunctionType = it.second->interfaceFunctionType();
Json::Value method;
2015-04-22 15:00:22 +00:00
method["type"] = "function";
2015-08-31 16:44:29 +00:00
method["name"] = it.second->declaration().name();
method["constant"] = it.second->isConstant();
2016-06-18 10:11:55 +00:00
method["payable"] = it.second->isPayable();
2015-05-11 14:24:04 +00:00
method["inputs"] = populateParameters(
2015-08-31 16:44:29 +00:00
externalFunctionType->parameterNames(),
externalFunctionType->parameterTypeNames(_contractDef.isLibrary())
2015-05-11 14:24:04 +00:00
);
method["outputs"] = populateParameters(
2015-08-31 16:44:29 +00:00
externalFunctionType->returnParameterNames(),
externalFunctionType->returnParameterTypeNames(_contractDef.isLibrary())
2015-05-11 14:24:04 +00:00
);
abi.append(method);
2015-04-22 15:00:22 +00:00
}
2015-08-31 16:44:29 +00:00
if (_contractDef.constructor())
2015-04-22 15:00:22 +00:00
{
Json::Value method;
method["type"] = "constructor";
2016-11-09 16:51:28 +00:00
auto externalFunction = FunctionType(*_contractDef.constructor(), false).interfaceFunctionType();
2015-04-22 15:00:22 +00:00
solAssert(!!externalFunction, "");
method["payable"] = externalFunction->isPayable();
2015-04-22 15:00:22 +00:00
method["inputs"] = populateParameters(
2015-08-31 16:44:29 +00:00
externalFunction->parameterNames(),
externalFunction->parameterTypeNames(_contractDef.isLibrary())
2015-04-22 15:00:22 +00:00
);
abi.append(method);
}
2016-06-18 09:56:01 +00:00
if (_contractDef.fallbackFunction())
{
2016-11-09 16:51:28 +00:00
auto externalFunctionType = FunctionType(*_contractDef.fallbackFunction(), false).interfaceFunctionType();
2016-06-18 09:56:01 +00:00
solAssert(!!externalFunctionType, "");
Json::Value method;
method["type"] = "fallback";
method["payable"] = externalFunctionType->isPayable();
2016-06-18 09:56:01 +00:00
abi.append(method);
}
2015-08-31 16:44:29 +00:00
for (auto const& it: _contractDef.interfaceEvents())
{
Json::Value event;
event["type"] = "event";
2015-08-31 16:44:29 +00:00
event["name"] = it->name();
2015-03-17 10:34:56 +00:00
event["anonymous"] = it->isAnonymous();
Json::Value params(Json::arrayValue);
2015-08-31 16:44:29 +00:00
for (auto const& p: it->parameters())
{
solAssert(!!p->annotation().type->interfaceType(false), "");
Json::Value input;
2015-08-31 16:44:29 +00:00
input["name"] = p->name();
input["type"] = p->annotation().type->interfaceType(false)->canonicalName(false);
input["indexed"] = p->isIndexed();
params.append(input);
}
event["inputs"] = params;
abi.append(event);
}
return abi;
}
Json::Value InterfaceHandler::userDocumentation(ContractDefinition const& _contractDef)
{
Json::Value doc;
Json::Value methods(Json::objectValue);
2015-08-31 16:44:29 +00:00
for (auto const& it: _contractDef.interfaceFunctions())
2015-10-26 14:13:36 +00:00
if (it.second->hasDeclaration())
if (auto const* f = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
{
string value = extractDoc(f->annotation().docTags, "notice");
if (!value.empty())
{
Json::Value user;
// since @notice is the only user tag if missing function should not appear
user["notice"] = Json::Value(value);
methods[it.second->externalSignature()] = user;
}
}
doc["methods"] = methods;
return doc;
}
Json::Value InterfaceHandler::devDocumentation(ContractDefinition const& _contractDef)
{
Json::Value doc;
Json::Value methods(Json::objectValue);
2015-10-26 14:13:36 +00:00
auto author = extractDoc(_contractDef.annotation().docTags, "author");
if (!author.empty())
doc["author"] = author;
auto title = extractDoc(_contractDef.annotation().docTags, "title");
if (!title.empty())
doc["title"] = title;
2015-08-31 16:44:29 +00:00
for (auto const& it: _contractDef.interfaceFunctions())
{
2015-10-26 14:13:36 +00:00
if (!it.second->hasDeclaration())
continue;
Json::Value method;
2015-10-26 14:13:36 +00:00
if (auto fun = dynamic_cast<FunctionDefinition const*>(&it.second->declaration()))
{
2015-10-26 14:13:36 +00:00
auto dev = extractDoc(fun->annotation().docTags, "dev");
if (!dev.empty())
method["details"] = Json::Value(dev);
2015-10-26 14:13:36 +00:00
auto author = extractDoc(fun->annotation().docTags, "author");
if (!author.empty())
method["author"] = author;
2015-10-26 14:13:36 +00:00
auto ret = extractDoc(fun->annotation().docTags, "return");
if (!ret.empty())
method["return"] = ret;
Json::Value params(Json::objectValue);
2015-10-26 14:13:36 +00:00
auto paramRange = fun->annotation().docTags.equal_range("param");
for (auto i = paramRange.first; i != paramRange.second; ++i)
params[i->second.paramName] = Json::Value(i->second.content);
2015-10-26 14:13:36 +00:00
if (!params.empty())
method["params"] = params;
2015-10-26 14:13:36 +00:00
if (!method.empty())
// add the function, only if we have any documentation to add
methods[it.second->externalSignature()] = method;
}
}
doc["methods"] = methods;
return doc;
}
2015-10-26 14:13:36 +00:00
string InterfaceHandler::extractDoc(multimap<string, DocTag> const& _tags, string const& _name)
{
2015-10-26 14:13:36 +00:00
string value;
auto range = _tags.equal_range(_name);
for (auto i = range.first; i != range.second; i++)
value += i->second.content;
return value;
}