blob: acdafa530d2a272631000b5238a6d1d3fac2ff86 [file] [log] [blame]
/* Compiler implementation of the D programming language
* Copyright (C) 1999-2019 by The D Language Foundation, All Rights Reserved
* written by Walter Bright
* http://www.digitalmars.com
* Distributed under the Boost Software License, Version 1.0.
* http://www.boost.org/LICENSE_1_0.txt
* https://github.com/D-Programming-Language/dmd/blob/master/src/json.c
*/
// This implements the JSON capability.
#include "root/dsystem.h"
#include "root/rmem.h"
#include "mars.h"
#include "dsymbol.h"
#include "template.h"
#include "aggregate.h"
#include "declaration.h"
#include "enum.h"
#include "module.h"
#include "json.h"
#include "mtype.h"
#include "attrib.h"
#include "cond.h"
#include "init.h"
#include "import.h"
#include "id.h"
#include "hdrgen.h"
class ToJsonVisitor : public Visitor
{
public:
OutBuffer *buf;
int indentLevel;
const char *filename;
ToJsonVisitor(OutBuffer *buf)
: buf(buf), indentLevel(0), filename(NULL)
{
}
void indent()
{
if (buf->offset >= 1 &&
buf->data[buf->offset - 1] == '\n')
for (int i = 0; i < indentLevel; i++)
buf->writeByte(' ');
}
void removeComma()
{
if (buf->offset >= 2 &&
buf->data[buf->offset - 2] == ',' &&
(buf->data[buf->offset - 1] == '\n' || buf->data[buf->offset - 1] == ' '))
buf->offset -= 2;
}
void comma()
{
if (indentLevel > 0)
buf->writestring(",\n");
}
void stringStart()
{
buf->writeByte('\"');
}
void stringEnd()
{
buf->writeByte('\"');
}
void stringPart(const char *s)
{
for (; *s; s++)
{
utf8_t c = (utf8_t) *s;
switch (c)
{
case '\n':
buf->writestring("\\n");
break;
case '\r':
buf->writestring("\\r");
break;
case '\t':
buf->writestring("\\t");
break;
case '\"':
buf->writestring("\\\"");
break;
case '\\':
buf->writestring("\\\\");
break;
case '\b':
buf->writestring("\\b");
break;
case '\f':
buf->writestring("\\f");
break;
default:
if (c < 0x20)
buf->printf("\\u%04x", c);
else
{
// Note that UTF-8 chars pass through here just fine
buf->writeByte(c);
}
break;
}
}
}
// Json value functions
/*********************************
* Encode string into buf, and wrap it in double quotes.
*/
void value(const char *s)
{
stringStart();
stringPart(s);
stringEnd();
}
void value(int value)
{
buf->printf("%d", value);
}
void valueBool(bool value)
{
buf->writestring(value ? "true" : "false");
}
/*********************************
* Item is an intented value and a comma, for use in arrays
*/
void item(const char *s)
{
indent();
value(s);
comma();
}
void item(int i)
{
indent();
value(i);
comma();
}
void itemBool(bool b)
{
indent();
valueBool(b);
comma();
}
// Json array functions
void arrayStart()
{
indent();
buf->writestring("[\n");
indentLevel++;
}
void arrayEnd()
{
indentLevel--;
removeComma();
if (buf->offset >= 2 &&
buf->data[buf->offset - 2] == '[' &&
buf->data[buf->offset - 1] == '\n')
buf->offset -= 1;
else if (!(buf->offset >= 1 &&
buf->data[buf->offset - 1] == '['))
{
buf->writestring("\n");
indent();
}
buf->writestring("]");
comma();
}
// Json object functions
void objectStart()
{
indent();
buf->writestring("{\n");
indentLevel++;
}
void objectEnd()
{
indentLevel--;
removeComma();
if (buf->offset >= 2 &&
buf->data[buf->offset - 2] == '{' &&
buf->data[buf->offset - 1] == '\n')
buf->offset -= 1;
else
{
buf->writestring("\n");
indent();
}
buf->writestring("}");
comma();
}
// Json object property functions
void propertyStart(const char *name)
{
indent();
value(name);
buf->writestring(" : ");
}
void property(const char *name, const char *s)
{
if (s == NULL) return;
propertyStart(name);
value(s);
comma();
}
void property(const char *name, int i)
{
propertyStart(name);
value(i);
comma();
}
void propertyBool(const char *name, bool b)
{
propertyStart(name);
valueBool(b);
comma();
}
void property(const char *name, TRUST trust)
{
switch (trust)
{
case TRUSTdefault:
// Should not be printed
//property(name, "default");
break;
case TRUSTsystem:
property(name, "system");
break;
case TRUSTtrusted:
property(name, "trusted");
break;
case TRUSTsafe:
property(name, "safe");
break;
default:
assert(false);
}
}
void property(const char *name, PURE purity)
{
switch (purity)
{
case PUREimpure:
// Should not be printed
//property(name, "impure");
break;
case PUREweak:
property(name, "weak");
break;
case PUREconst:
property(name, "const");
break;
case PUREstrong:
property(name, "strong");
break;
case PUREfwdref:
property(name, "fwdref");
break;
default:
assert(false);
}
}
void property(const char *name, LINK linkage)
{
switch (linkage)
{
case LINKdefault:
// Should not be printed
//property(name, "default");
break;
case LINKd:
// Should not be printed
//property(name, "d");
break;
case LINKc:
property(name, "c");
break;
case LINKcpp:
property(name, "cpp");
break;
case LINKwindows:
property(name, "windows");
break;
case LINKpascal:
property(name, "pascal");
break;
default:
assert(false);
}
}
void propertyStorageClass(const char *name, StorageClass stc)
{
stc &= STCStorageClass;
if (stc)
{
propertyStart(name);
arrayStart();
while (stc)
{
const char *p = stcToChars(stc);
assert(p);
item(p);
}
arrayEnd();
}
}
void property(const char *linename, const char *charname, Loc *loc)
{
if (loc)
{
const char *filename = loc->filename;
if (filename)
{
if (!this->filename || strcmp(filename, this->filename))
{
this->filename = filename;
property("file", filename);
}
}
if (loc->linnum)
{
property(linename, loc->linnum);
if (loc->charnum)
property(charname, loc->charnum);
}
}
}
void property(const char *name, Type *type)
{
if (type)
{
property(name, type->toChars());
}
}
void property(const char *name, const char *deconame, Type *type)
{
if (type)
{
if (type->deco)
property(deconame, type->deco);
else
property(name, type->toChars());
}
}
void property(const char *name, Parameters *parameters)
{
if (parameters == NULL || parameters->dim == 0)
return;
propertyStart(name);
arrayStart();
if (parameters)
{
for (size_t i = 0; i < parameters->dim; i++)
{
Parameter *p = (*parameters)[i];
objectStart();
if (p->ident)
property("name", p->ident->toChars());
property("type", "deco", p->type);
propertyStorageClass("storageClass", p->storageClass);
if (p->defaultArg)
property("default", p->defaultArg->toChars());
objectEnd();
}
}
arrayEnd();
}
/* ========================================================================== */
void jsonProperties(Dsymbol *s)
{
if (s->isModule())
return;
if (!s->isTemplateDeclaration()) // TemplateDeclaration::kind() acts weird sometimes
{
property("name", s->toChars());
property("kind", s->kind());
}
if (s->prot().kind != PROTpublic) // TODO: How about package(names)?
property("protection", protectionToChars(s->prot().kind));
if (EnumMember *em = s->isEnumMember())
{
if (em->origValue)
property("value", em->origValue->toChars());
}
property("comment", (const char *)s->comment);
property("line", "char", &s->loc);
}
void jsonProperties(Declaration *d)
{
jsonProperties((Dsymbol *)d);
propertyStorageClass("storageClass", d->storage_class);
property("type", "deco", d->type);
// Emit originalType if it differs from type
if (d->type != d->originalType && d->originalType)
{
const char *ostr = d->originalType->toChars();
if (d->type)
{
const char *tstr = d->type->toChars();
if (strcmp(tstr, ostr))
{
//printf("tstr = %s, ostr = %s\n", tstr, ostr);
property("originalType", ostr);
}
}
else
property("originalType", ostr);
}
}
void jsonProperties(TemplateDeclaration *td)
{
jsonProperties((Dsymbol *)td);
if (td->onemember && td->onemember->isCtorDeclaration())
property("name", "this"); // __ctor -> this
else
property("name", td->ident->toChars()); // Foo(T) -> Foo
}
/* ========================================================================== */
void visit(Dsymbol *)
{
}
void visit(Module *s)
{
objectStart();
if (s->md)
property("name", s->md->toChars());
property("kind", s->kind());
filename = s->srcfile->toChars();
property("file", filename);
property("comment", (const char *)s->comment);
propertyStart("members");
arrayStart();
for (size_t i = 0; i < s->members->dim; i++)
{
(*s->members)[i]->accept(this);
}
arrayEnd();
objectEnd();
}
void visit(Import *s)
{
if (s->id == Id::object)
return;
objectStart();
propertyStart("name");
stringStart();
if (s->packages && s->packages->dim)
{
for (size_t i = 0; i < s->packages->dim; i++)
{
Identifier *pid = (*s->packages)[i];
stringPart(pid->toChars());
buf->writeByte('.');
}
}
stringPart(s->id->toChars());
stringEnd();
comma();
property("kind", s->kind());
property("comment", (const char *)s->comment);
property("line", "char", &s->loc);
if (s->prot().kind != PROTpublic)
property("protection", protectionToChars(s->prot().kind));
if (s->aliasId)
property("alias", s->aliasId->toChars());
bool hasRenamed = false;
bool hasSelective = false;
for (size_t i = 0; i < s->aliases.dim; i++)
{
// avoid empty "renamed" and "selective" sections
if (hasRenamed && hasSelective)
break;
else if (s->aliases[i])
hasRenamed = true;
else
hasSelective = true;
}
if (hasRenamed)
{
// import foo : alias1 = target1;
propertyStart("renamed");
objectStart();
for (size_t i = 0; i < s->aliases.dim; i++)
{
Identifier *name = s->names[i];
Identifier *alias = s->aliases[i];
if (alias) property(alias->toChars(), name->toChars());
}
objectEnd();
}
if (hasSelective)
{
// import foo : target1;
propertyStart("selective");
arrayStart();
for (size_t i = 0; i < s->names.dim; i++)
{
Identifier *name = s->names[i];
if (!s->aliases[i]) item(name->toChars());
}
arrayEnd();
}
objectEnd();
}
void visit(AttribDeclaration *d)
{
Dsymbols *ds = d->include(NULL, NULL);
if (ds)
{
for (size_t i = 0; i < ds->dim; i++)
{
Dsymbol *s = (*ds)[i];
s->accept(this);
}
}
}
void visit(ConditionalDeclaration *d)
{
if (d->condition->inc)
{
visit((AttribDeclaration *)d);
}
}
void visit(TypeInfoDeclaration *) {}
void visit(PostBlitDeclaration *) {}
void visit(Declaration *d)
{
objectStart();
//property("unknown", "declaration");
jsonProperties(d);
objectEnd();
}
void visit(AggregateDeclaration *d)
{
objectStart();
jsonProperties(d);
ClassDeclaration *cd = d->isClassDeclaration();
if (cd)
{
if (cd->baseClass && cd->baseClass->ident != Id::Object)
{
property("base", cd->baseClass->toPrettyChars(true));
}
if (cd->interfaces.length)
{
propertyStart("interfaces");
arrayStart();
for (size_t i = 0; i < cd->interfaces.length; i++)
{
BaseClass *b = cd->interfaces.ptr[i];
item(b->sym->toPrettyChars(true));
}
arrayEnd();
}
}
if (d->members)
{
propertyStart("members");
arrayStart();
for (size_t i = 0; i < d->members->dim; i++)
{
Dsymbol *s = (*d->members)[i];
s->accept(this);
}
arrayEnd();
}
objectEnd();
}
void visit(FuncDeclaration *d)
{
objectStart();
jsonProperties(d);
TypeFunction *tf = (TypeFunction *)d->type;
if (tf && tf->ty == Tfunction)
property("parameters", tf->parameters);
property("endline", "endchar", &d->endloc);
if (d->foverrides.dim)
{
propertyStart("overrides");
arrayStart();
for (size_t i = 0; i < d->foverrides.dim; i++)
{
FuncDeclaration *fd = d->foverrides[i];
item(fd->toPrettyChars());
}
arrayEnd();
}
if (d->fdrequire)
{
propertyStart("in");
d->fdrequire->accept(this);
}
if (d->fdensure)
{
propertyStart("out");
d->fdensure->accept(this);
}
objectEnd();
}
void visit(TemplateDeclaration *d)
{
objectStart();
// TemplateDeclaration::kind returns the kind of its Aggregate onemember, if it is one
property("kind", "template");
jsonProperties(d);
propertyStart("parameters");
arrayStart();
for (size_t i = 0; i < d->parameters->dim; i++)
{
TemplateParameter *s = (*d->parameters)[i];
objectStart();
property("name", s->ident->toChars());
TemplateTypeParameter *type = s->isTemplateTypeParameter();
if (type)
{
if (s->isTemplateThisParameter())
property("kind", "this");
else
property("kind", "type");
property("type", "deco", type->specType);
property("default", "defaultDeco", type->defaultType);
}
TemplateValueParameter *value = s->isTemplateValueParameter();
if (value)
{
property("kind", "value");
property("type", "deco", value->valType);
if (value->specValue)
property("specValue", value->specValue->toChars());
if (value->defaultValue)
property("defaultValue", value->defaultValue->toChars());
}
TemplateAliasParameter *alias = s->isTemplateAliasParameter();
if (alias)
{
property("kind", "alias");
property("type", "deco", alias->specType);
if (alias->specAlias)
property("specAlias", alias->specAlias->toChars());
if (alias->defaultAlias)
property("defaultAlias", alias->defaultAlias->toChars());
}
TemplateTupleParameter *tuple = s->isTemplateTupleParameter();
if (tuple)
{
property("kind", "tuple");
}
objectEnd();
}
arrayEnd();
Expression *expression = d->constraint;
if (expression)
{
property("constraint", expression->toChars());
}
propertyStart("members");
arrayStart();
for (size_t i = 0; i < d->members->dim; i++)
{
Dsymbol *s = (*d->members)[i];
s->accept(this);
}
arrayEnd();
objectEnd();
}
void visit(EnumDeclaration *d)
{
if (d->isAnonymous())
{
if (d->members)
{
for (size_t i = 0; i < d->members->dim; i++)
{
Dsymbol *s = (*d->members)[i];
s->accept(this);
}
}
return;
}
objectStart();
jsonProperties(d);
property("base", "baseDeco", d->memtype);
if (d->members)
{
propertyStart("members");
arrayStart();
for (size_t i = 0; i < d->members->dim; i++)
{
Dsymbol *s = (*d->members)[i];
s->accept(this);
}
arrayEnd();
}
objectEnd();
}
void visit(EnumMember *s)
{
objectStart();
jsonProperties((Dsymbol*)s);
property("type", "deco", s->origType);
objectEnd();
}
void visit(VarDeclaration *d)
{
objectStart();
jsonProperties(d);
if (d->_init)
property("init", d->_init->toChars());
if (d->isField())
property("offset", d->offset);
if (d->alignment && d->alignment != STRUCTALIGN_DEFAULT)
property("align", d->alignment);
objectEnd();
}
void visit(TemplateMixin *d)
{
objectStart();
jsonProperties(d);
objectEnd();
}
};
void json_generate(OutBuffer *buf, Modules *modules)
{
ToJsonVisitor json(buf);
json.arrayStart();
for (size_t i = 0; i < modules->dim; i++)
{
Module *m = (*modules)[i];
if (global.params.verbose)
message("json gen %s", m->toChars());
m->accept(&json);
}
json.arrayEnd();
json.removeComma();
}