compilerplugins/clang/getimplementationname.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 // only compile this on unixy system
  11 // as we don't want to bother with x-platform system()/mkdir()
  12 #if defined(__unix__)
  13 // only compile this on clang 3.7 or higher, which is known to work
  14 // there were problems on clang 3.5 at least
  15 #include "config_clang.h"
  16 #include <cassert>
  17 #include <stdlib.h>
  18 #include <string>
  19 #include <iostream>
  20 #include <fstream>
  21 #include <regex>
  22 #include "check.hxx"
  23 #include "plugin.hxx"
  24 #include "clang/Frontend/CompilerInstance.h"
  25
  26 namespace {
  27
  28 clang::Expr const * ignoreParenImplicitComma(clang::Expr const * expr) {
  29     for (;;) {
  30         auto const e1 = expr->IgnoreParens()->IgnoreImplicit();
  31         if (e1 != expr) {
  32             expr = e1;
  33             continue;
  34         }
  35         // auto const e1 = dyn_cast<clang::ExprWithCleanups>(expr);
  36         // if (e1 != nullptr) {
  37         //     expr = e1->getSubExpr();
  38         //     continue;
  39         // }
  40         auto const e2 = dyn_cast<clang::BinaryOperator>(expr);
  41         if (e2 != nullptr && e2->getOpcode() == clang::BO_Comma) {
  42             expr = e2->getRHS();
  43             continue;
  44         }
  45         return expr;
  46     }
  47 }
  48
  49 bool overridesXServiceInfo(clang::CXXMethodDecl const * decl) {
  50     for (auto i = decl->begin_overridden_methods();
  51          i != decl->end_overridden_methods(); ++i)
  52     {
  53         if (((*i)->getParent()->getQualifiedNameAsString()
  54              == "com::sun::star::lang::XServiceInfo")
  55             || overridesXServiceInfo(*i))
  56         {
  57             return true;
  58         }
  59     }
  60     return false;
  61 }
  62
  63 std::string replace_all(std::string subject, const std::string& search, const std::string& replace)
  64 {
  65     size_t pos = 0;
  66
  67     while ((pos = subject.find(search, pos)) != std::string::npos)
  68     {
  69         subject.replace(pos, search.length(), replace);
  70         pos += replace.length();
  71     }
  72
  73     return subject;
  74 }
  75
  76 class GetImplementationName:
  77     public clang::RecursiveASTVisitor<GetImplementationName>,
  78     public loplugin::Plugin
  79 {
  80 public:
  81     explicit GetImplementationName(loplugin::InstantiationData const & data)
  82         : Plugin(data)
  83         , m_Outdir(initOutdir())
  84         , m_OutdirCreated(false)
  85         , m_Srcdir(initSrcdir())
  86     {}
  87     void run() override;
  88
  89     bool VisitCXXMethodDecl(clang::CXXMethodDecl const * decl);
  90
  91 private:
  92     bool isStringConstant(Expr const * expr, clang::StringRef * string);
  93
  94     bool returnsStringConstant(
  95         FunctionDecl const * decl, clang::StringRef * string);
  96
  97     void ensureOutdirCreated()
  98     {
  99         if(m_OutdirCreated)
 100             return;
 101         std::string cmd("mkdir -p ");
 102         cmd += "\"" + m_Outdir + "\"";
 103         if(system(cmd.c_str()) != 0) {
 104             report(
 105                 clang::DiagnosticsEngine::Error,
 106                 "Error creating ServiceImplementations output dir \"%0\".")
 107                 << m_Outdir;
 108         }
 109         m_OutdirCreated = true;
 110     }
 111
 112     void generateOutput(FunctionDecl const * decl, const std::string unoimpl, const std::string cppclass);
 113     std::string initOutdir();
 114     std::string initSrcdir();
 115     const std::string m_Outdir;
 116     bool m_OutdirCreated;
 117     const std::string m_Srcdir;
 118 };
 119
 120 void GetImplementationName::run() {
 121     if (compiler.getLangOpts().CPlusPlus) {
 122         TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());
 123     }
 124 }
 125
 126 bool GetImplementationName::VisitCXXMethodDecl(
 127     clang::CXXMethodDecl const * decl)
 128 {
 129     if (ignoreLocation(decl) || !decl->doesThisDeclarationHaveABody()
 130         || !decl->isVirtual())
 131     {
 132         return true;
 133     }
 134     auto const id = decl->getIdentifier();
 135     if (id == nullptr || id->getName() != "getImplementationName"
 136         || !overridesXServiceInfo(decl))
 137     {
 138         return true;
 139     }
 140     clang::StringRef unoimpl;
 141     if (!returnsStringConstant(decl, &unoimpl)) {
 142         report(
 143             clang::DiagnosticsEngine::Warning,
 144             "cannot determine returned string", decl->getLocation())
 145             << decl->getSourceRange();
 146         return true;
 147     }
 148     generateOutput(decl, unoimpl.str(), decl->getParent()->getQualifiedNameAsString());
 149     return true;
 150 }
 151
 152 bool GetImplementationName::isStringConstant(
 153     Expr const * expr, clang::StringRef * string)
 154 {
 155     QualType t = expr->getType();
 156     if (!(t->isConstantArrayType() && t.isConstQualified()
 157           && (loplugin::TypeCheck(t->getAsArrayTypeUnsafe()->getElementType())
 158               .Char())))
 159     {
 160         return false;
 161     }
 162     DeclRefExpr const * dre = dyn_cast<DeclRefExpr>(expr);
 163     if (dre != nullptr) {
 164         VarDecl const * var = dyn_cast<VarDecl>(dre->getDecl());
 165         if (var != nullptr) {
 166             Expr const * init = var->getAnyInitializer();
 167             if (init != nullptr) {
 168                 expr = ignoreParenImplicitComma(init);
 169             }
 170         }
 171     }
 172     clang::StringLiteral const * lit = dyn_cast<clang::StringLiteral>(expr);
 173     if (lit != nullptr) {
 174         if (!lit->isAscii()) {
 175             return false;
 176         }
 177         *string = lit->getString();
 178         return true;
 179     }
 180     APValue v;
 181     if (!expr->isCXX11ConstantExpr(compiler.getASTContext(), &v)) {
 182         return false;
 183     }
 184     switch (v.getKind()) {
 185     case APValue::LValue:
 186         return false; //TODO
 187     case APValue::Array:
 188         {
 189             if (v.hasArrayFiller()) { //TODO: handle final NUL filler?
 190                 return false;
 191             }
 192             unsigned n = v.getArraySize();
 193             assert(n != 0);
 194             for (unsigned i = 0; i != n; ++i) {
 195                 APValue e(v.getArrayInitializedElt(i));
 196                 if (!e.isInt()) { //TODO: assert?
 197                     return false;
 198                 }
 199                 APSInt iv = e.getInt();
 200                 if (iv == 0) {
 201                     if (i == n -1) {
 202                         continue;
 203                     }
 204                     return false;
 205                 } else if (iv.uge(0x80)) {
 206                     return false;
 207                 }
 208                 //TODO
 209             }
 210             return false;//TODO
 211         }
 212     default:
 213         assert(false); //TODO???
 214         return "BAD11";
 215     }
 216 }
 217
 218 bool GetImplementationName::returnsStringConstant(
 219     FunctionDecl const * decl, clang::StringRef * string)
 220 {
 221     auto s1 = decl->getBody();
 222     if (s1 == nullptr) {
 223         return false;
 224     }
 225     for (;;) {
 226         auto s2 = dyn_cast<clang::CompoundStmt>(s1);
 227         if (s2 == nullptr) {
 228             auto const s3 = dyn_cast<clang::CXXTryStmt>(s1);
 229             if (s3 == nullptr) {
 230                 break;
 231             }
 232             s2 = s3->getTryBlock();
 233         }
 234         if (s2->size() != 1) {
 235             break;
 236         }
 237         s1 = s2->body_front();
 238     }
 239     auto const s4 = dyn_cast<clang::ReturnStmt>(s1);
 240     if (s4 == nullptr) {
 241         return false;
 242     }
 243     for (auto e1 = ignoreParenImplicitComma(s4->getRetValue());;) {
 244         auto const e2 = dyn_cast<clang::CallExpr>(e1);
 245         if (e2 != nullptr) {
 246             auto const d = e2->getDirectCallee();
 247             return d != nullptr && returnsStringConstant(d, string);
 248         }
 249         auto const e3 = dyn_cast<clang::CXXFunctionalCastExpr>(e1);
 250         if (e3 != nullptr) {
 251             e1 = ignoreParenImplicitComma(e3->getSubExpr());
 252             continue;
 253         }
 254         auto const e4 = dyn_cast<clang::CXXConstructExpr>(e1);
 255         if (e4 != nullptr)  {
 256             if (e4->getNumArgs() < 1) {
 257                 return false;
 258             }
 259             e1 = ignoreParenImplicitComma(e4->getArg(0));
 260             continue;
 261         }
 262         return isStringConstant(e1, string);
 263     }
 264 }
 265
 266 void GetImplementationName::generateOutput(FunctionDecl const * decl, const std::string unoimpl, const std::string cppclass) {
 267     ensureOutdirCreated();
 268     clang::SourceManager& sm(compiler.getSourceManager());
 269     const std::string absfilename(sm.getFilename(decl->getSourceRange().getBegin()).str());
 270     if(absfilename.length() <= m_Srcdir.length())
 271         return;
 272     const std::string filename(absfilename.substr(m_Srcdir.length()+1));
 273     const std::regex moduleregex("^\\w+");
 274     std::smatch modulematch;
 275     std::regex_search(filename, modulematch, moduleregex);
 276     if(modulematch.empty())
 277         return;
 278     const std::string module(modulematch[0]);
 279     const std::string doublecolonregex("::");
 280     const std::string cppclassweb(replace_all(cppclass, doublecolonregex, "_1_1"));
 281     std::ofstream redirectfile(m_Outdir + "/" + unoimpl + ".html");
 282     redirectfile << "<meta http-equiv=\"refresh\" content=\"0; URL=http://docs.libreoffice.org/" << module << "/html/class" << cppclassweb << "\">\n";
 283     redirectfile.close();
 284 }
 285
 286 std::string GetImplementationName::initOutdir() {
 287 {
 288     char* pWorkdir = getenv("WORKDIR");
 289     if(pWorkdir) {
 290         std::string result(pWorkdir);
 291         result += "/ServiceImplementations";
 292         return result;
 293     }
 294     report(
 295         clang::DiagnosticsEngine::Error, "WORKDIR unset, don't know where to write service implementation info.");
 296     return std::string();
 297     }
 298 }
 299
 300 std::string GetImplementationName::initSrcdir() {
 301 {
 302     char* pSrcdir = getenv("SRCDIR");
 303     if(!pSrcdir) {
 304         report(
 305             clang::DiagnosticsEngine::Error, "SRCDIR unset, don't know where the source base is.");
 306     }
 307     return std::string(pSrcdir);
 308     }
 309 }
 310 loplugin::Plugin::Registration<GetImplementationName> X(
 311     "getimplementationname", false);
 312 }
 313 #endif
 314
 315 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */