Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 480 insertions, 0 deletions

diff --git a/compilerplugins/clang/sharedvisitor/generator.cxx b/compilerplugins/clang/sharedvisitor/generator.cxx
new file mode 100644
index 000000000..ca5d2743c
--- /dev/null
+++ b/compilerplugins/clang/sharedvisitor/generator.cxx
@@ -0,0 +1,480 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * 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/.
+ */
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <iostream>
+#include <fstream>
+#include <memory>
+#include <set>
+#include <vector>
+
+// Info about a Visit* function in a plugin.
+struct VisitFunctionInfo
+{
+    std::string name;
+    std::string argument;
+};
+
+
+// Info about a Traverse* function in a plugin.
+struct TraverseFunctionInfo
+{
+    std::string name;
+    std::string argument;
+    bool hasPre = false;
+    bool hasPost = false;
+};
+
+struct VisitFunctionInfoLess
+{
+    bool operator()( const VisitFunctionInfo& l, const VisitFunctionInfo& r ) const
+    {
+        return l.name < r.name;
+    }
+};
+
+struct TraverseFunctionInfoLess
+{
+    bool operator()( const TraverseFunctionInfo& l, const TraverseFunctionInfo& r ) const
+    {
+        return l.name < r.name;
+    }
+};
+
+
+// Information about each LO plugin.
+struct PluginInfo
+{
+    std::string className; // e.g. "BadStatics"
+    std::string variableName; // e.g. "badStatics"
+    std::string lowercaseName;
+    bool shouldVisitTemplateInstantiations;
+    bool shouldVisitImplicitCode;
+    std::set< VisitFunctionInfo, VisitFunctionInfoLess > visitFunctions;
+    std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions;
+};
+
+// We need separate visitors for shouldVisitTemplateInstantiations and shouldVisitImplicitCode,
+// so split plugins into groups by what they should visit.
+// It seems that trying to handle the shouldVisit* functionality with just one visitor
+// is tricky.
+enum PluginType
+{
+    PluginBasic,
+    PluginVisitTemplates,
+    PluginVisitImplicit,
+    PluginVisitTemplatesImplicit,
+};
+
+const int Plugin_Begin = PluginBasic;
+const int Plugin_End = PluginVisitTemplatesImplicit + 1;
+static const char* const pluginTypeNames[ Plugin_End ]
+    = { "Basic", "VisitTemplates", "VisitImplicit", "VisitTemplatesImplicit" };
+
+static std::vector< PluginInfo > plugins[ Plugin_End ];
+
+
+void generateVisitor( PluginType type );
+
+void generate()
+{
+    std::ostream& output = std::cout;
+    output <<
+"// This file is autogenerated. Do not modify.\n"
+"// Generated by compilerplugins/clang/sharedvisitor/generator.cxx .\n"
+"\n"
+"#ifdef LO_CLANG_SHARED_PLUGINS\n"
+"\n"
+"#include <config_clang.h>\n"
+"\n"
+"#include <clang/AST/ASTContext.h>\n"
+"#include <clang/AST/RecursiveASTVisitor.h>\n"
+"\n"
+"#include \"plugin.hxx\"\n"
+"#include \"sharedvisitor/dummyplugin.hxx\"\n"
+"\n";
+
+    output << "#undef LO_CLANG_SHARED_PLUGINS // to get sources of individual plugins\n";
+    output << "// make use of the dummy base classes\n";
+    output << "#define RecursiveASTVisitor DummyRecursiveASTVisitor\n";
+    output << "#define FilteringPlugin DummyFilteringPlugin\n";
+    output << "#define FilteringRewritePlugin DummyFilteringRewritePlugin\n";
+    output << "\n";
+    for( const auto& pluginGroup : plugins )
+        for( const PluginInfo& plugin : pluginGroup )
+            output << "#include \"" << plugin.lowercaseName << ".cxx\"" << std::endl;
+    output << "\n";
+    output << "#undef RecursiveASTVisitor\n";
+    output << "#undef FilteringPlugin\n";
+    output << "#undef FilteringRewritePlugin\n";
+
+    output <<
+"\n"
+"using namespace clang;\n"
+"using namespace llvm;\n"
+"\n"
+"namespace loplugin\n"
+"{\n";
+
+    for( int type = Plugin_Begin; type < Plugin_End; ++type )
+        generateVisitor( static_cast< PluginType >( type ));
+
+    output <<
+"} // namespace loplugin\n"
+"\n"
+"#endif // LO_CLANG_SHARED_PLUGINS\n";
+}
+
+void generateVisitor( PluginType type )
+{
+    if( plugins[ type ].empty())
+        return;
+    std::ostream& output = std::cout;
+    output <<
+"\n"
+"class SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "\n"
+"    : public FilteringPlugin< SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << ">\n"
+"{\n"
+"public:\n"
+"    explicit SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "(const InstantiationData& rData)\n"
+"        : FilteringPlugin(rData)\n";
+    for( const PluginInfo& plugin : plugins[ type ] )
+        output << "        , " << plugin.variableName << "( nullptr )\n";
+    output << "        , activeRefCount( 0 )\n";
+    output << "    {}\n";
+
+    output <<
+"    ~SharedRecursiveASTVisitor" << pluginTypeNames[ type ] << "()\n"
+"    {\n"
+"        if( activeRefCount != 0 )\n"
+"            abort();\n"
+"    }\n";
+
+    output <<
+"    virtual bool preRun() override\n"
+"    {\n";
+    for( const PluginInfo& plugin : plugins[ type ] )
+    {
+        output << "        if( " << plugin.variableName << " && !" << plugin.variableName << "->preRun())\n";
+        // This will disable the plugin for the rest of the run.
+        output << "            " << plugin.variableName << " = nullptr;\n";
+    }
+    output <<
+"        return anyPluginActive();\n"
+"    }\n";
+
+    output <<
+"    virtual void postRun() override\n"
+"    {\n";
+    for( const PluginInfo& plugin : plugins[ type ] )
+    {
+        output << "        if( " << plugin.variableName << " )\n";
+        output << "            " << plugin.variableName << "->postRun();\n";
+    }
+    output <<
+"    }\n";
+
+    output <<
+"    virtual void run() override {\n"
+"        if (preRun()) {\n"
+"            TraverseDecl(compiler.getASTContext().getTranslationUnitDecl());\n"
+"            postRun();\n"
+"        }\n"
+"    }\n"
+"    enum { isSharedPlugin = true };\n";
+
+    output <<
+"    virtual bool setSharedPlugin( Plugin* plugin, const char* name ) override\n"
+"    {\n";
+    bool first = true;
+    for( const PluginInfo& plugin : plugins[ type ] )
+    {
+        output << "        ";
+        if( !first )
+            output << "else ";
+        first = false;
+        output << "if( strcmp( name, \"" << plugin.lowercaseName << "\" ) == 0 )\n";
+        output << "            " << plugin.variableName << " = static_cast< " << plugin.className << "* >( plugin );\n";
+    }
+    output <<
+"        else\n"
+"            return false;\n"
+"        return true;\n"
+"    }\n";
+
+    if( type == PluginVisitTemplates || type == PluginVisitTemplatesImplicit )
+        output << "bool shouldVisitTemplateInstantiations() const { return true; }\n";
+    if( type == PluginVisitImplicit || type == PluginVisitTemplatesImplicit )
+        output << "bool shouldVisitImplicitCode() const { return true; }\n";
+
+    std::set< VisitFunctionInfo, VisitFunctionInfoLess > visitFunctions;
+    for( const PluginInfo& plugin : plugins[ type ] )
+        for( const VisitFunctionInfo& visit : plugin.visitFunctions )
+            visitFunctions.insert( visit );
+    for( const VisitFunctionInfo& visit : visitFunctions )
+    {
+        output << "    bool " << visit.name << "(" << visit.argument << " arg)\n";
+        output <<
+"    {\n"
+"        if( ignoreLocation( arg ))\n"
+"            return true;\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            if( plugin.visitFunctions.find( visit ) == plugin.visitFunctions.end())
+                continue;
+            output << "        if( " << plugin.variableName << " != nullptr ";
+            output << ")\n";
+            output << "        {\n";
+            output << "            if( !" << plugin.variableName << "->" << visit.name << "( arg ))\n";
+            // This will disable the plugin for the rest of the run (as would returning false
+            // from Visit* normally do in the non-shared case).
+            output << "                " << plugin.variableName << " = nullptr;\n";
+            output << "        }\n";
+        }
+        output <<
+"        return anyPluginActive();\n"
+"    }\n";
+    }
+
+    std::set< TraverseFunctionInfo, TraverseFunctionInfoLess > traverseFunctions;
+    for( const PluginInfo& plugin : plugins[ type ] )
+        for( const TraverseFunctionInfo& traverse : plugin.traverseFunctions )
+            traverseFunctions.insert( traverse );
+    for( const TraverseFunctionInfo& traverse : traverseFunctions )
+    {
+        output << "    bool " << traverse.name << "(" << traverse.argument << " arg)\n";
+        output << "    {\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            auto pluginTraverse = plugin.traverseFunctions.find( traverse );
+            if( pluginTraverse == plugin.traverseFunctions.end())
+                continue;
+            output << "        " << plugin.className << "* save" << plugin.className << " = " << plugin.variableName << ";\n";
+            if( pluginTraverse->hasPre )
+            {
+                output << "        if( " << plugin.variableName << " != nullptr ";
+                output << ")\n";
+                output << "        {\n";
+                output << "            if( !" << plugin.variableName << "->Pre" << traverse.name << "( arg ))\n";
+                // This will disable the plugin for the time of the traverse, until restored later,
+                // just like directly returning from Traverse* would skip that part.
+                output << "            {\n";
+                output << "                " << plugin.variableName << " = nullptr;\n";
+                output << "                ++activeRefCount;\n";
+                output << "            }\n";
+                output << "        }\n";
+            }
+        }
+        output << "        bool ret = RecursiveASTVisitor::" << traverse.name << "( arg );\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            auto pluginTraverse = plugin.traverseFunctions.find( traverse );
+            if( pluginTraverse == plugin.traverseFunctions.end())
+                continue;
+            if( pluginTraverse->hasPost )
+            {
+                output << "        if( " << plugin.variableName << " != nullptr ";
+                output << ")\n";
+                output << "        {\n";
+                output << "            if( !" << plugin.variableName << "->Post" << traverse.name << "( arg, ret ))\n";
+                // This will disable the plugin for the rest of the run.
+                output << "                save" << plugin.className << " = nullptr;\n";
+                output << "        }\n";
+            }
+            output << "        if( " << plugin.variableName << " == nullptr && save" << plugin.className << " != nullptr )\n";
+            output << "            --activeRefCount;\n";
+            output << "        " << plugin.variableName << " = save" << plugin.className << ";\n";
+        }
+        output << "        if( false ) // silence -Wunused-function warnings\n";
+        output << "        {\n";
+        for( const PluginInfo& plugin : plugins[ type ] )
+        {
+            auto pluginTraverse = plugin.traverseFunctions.find( traverse );
+            if( pluginTraverse == plugin.traverseFunctions.end())
+                continue;
+            output << "            " << plugin.variableName << "->" << pluginTraverse->name << "( arg );\n";
+        }
+        output << "        }\n";
+        output << "        return ret;\n";
+        output << "    }\n";
+    }
+
+    output <<
+"private:\n";
+
+    output <<
+"    bool anyPluginActive() const\n"
+"    {\n"
+"        return activeRefCount > 0";
+    for( const PluginInfo& plugin : plugins[ type ] )
+        output << "\n            || " << plugin.variableName << " != nullptr";
+    output << ";\n";
+    output << "    }\n";
+
+    for( const PluginInfo& plugin : plugins[ type ] )
+        output << "    " << plugin.className << "* " << plugin.variableName << ";\n";
+    output << "    int activeRefCount;\n";
+
+    output <<
+"};\n"
+"\n"
+"loplugin::Plugin::Registration< SharedRecursiveASTVisitor" << pluginTypeNames[ type ]
+    << " > registration" << pluginTypeNames[ type ] << "(\"sharedvisitor" << pluginTypeNames[ type ] << "\");\n"
+"\n";
+}
+
+static std::string getValue( const std::string& line, const char* tag )
+{
+    size_t taglen = strlen( tag );
+    if( line.size() < taglen + 2 )
+        return std::string();
+    if( line.compare( 0, taglen, tag ) != 0 )
+        return std::string();
+    if( line[ taglen ] != ':' )
+        return std::string();
+    return line.substr( taglen + 1 );
+}
+
+static bool readFile( const std::string& fileName )
+{
+    std::ifstream file( fileName );
+    if( !file )
+    {
+        std::cerr << "Cannot open file " << fileName << std::endl;
+        return false;
+    }
+    PluginInfo pluginInfo;
+    std::string line;
+    do
+    {
+        getline( file, line );
+    } while( !line.empty() && line[ 0 ] == '#' );
+    std::string version = getValue( line, "InfoVersion" );
+    if( version != "1" )
+    {
+        std::cerr << "Incorrect version '" << version << "' in " << fileName << std::endl;
+        return false;
+    }
+    getline( file, line );
+    pluginInfo.className = getValue( line, "ClassName" );
+    pluginInfo.variableName = pluginInfo.className;
+    assert( pluginInfo.variableName.size() > 0 );
+    pluginInfo.variableName[ 0 ] = tolower( pluginInfo.variableName[ 0 ] );
+    pluginInfo.lowercaseName = pluginInfo.className;
+    for( char& c : pluginInfo.lowercaseName )
+        c = tolower( c );
+    pluginInfo.shouldVisitTemplateInstantiations = false;
+    pluginInfo.shouldVisitImplicitCode = false;
+    bool endOk = false;
+    for(;;)
+    {
+        std::string line;
+        getline( file, line );
+        if( file.eof() || !file )
+        {
+            std::cerr << "Unexpected end of file" << std::endl;
+            return false;
+        }
+        if( line.empty())
+            continue;
+        if( line == "InfoEnd" )
+        {
+            endOk = true;
+            break;
+        }
+        else if( line == "VisitFunctionStart" )
+        {
+            VisitFunctionInfo visitInfo;
+            getline( file, line );
+            visitInfo.name = getValue( line, "VisitFunctionName" );
+            getline( file, line );
+            visitInfo.argument = getValue( line, "VisitFunctionArgument" );
+            getline( file, line );
+            if( line != "VisitFunctionEnd" )
+            {
+                std::cerr << "Missing VisitFunctionEnd" << std::endl;
+                return false;
+            }
+            pluginInfo.visitFunctions.insert( std::move( visitInfo ));
+        }
+        else if( line == "TraverseFunctionStart" )
+        {
+            TraverseFunctionInfo traverseInfo;
+            getline( file, line );
+            traverseInfo.name = getValue( line, "TraverseFunctionName" );
+            getline( file, line );
+            traverseInfo.argument = getValue( line, "TraverseFunctionArgument" );
+            getline( file, line );
+            traverseInfo.hasPre = getValue( line, "TraverseFunctionHasPre" ) == "1";
+            getline( file, line );
+            traverseInfo.hasPost = getValue( line, "TraverseFunctionHasPost" ) == "1";
+            getline( file, line );
+            if( line != "TraverseFunctionEnd" )
+            {
+                std::cerr << "Missing TraverseFunctionEnd" << std::endl;
+                return false;
+            }
+            pluginInfo.traverseFunctions.insert( std::move( traverseInfo ));
+        }
+        else
+        {
+            std::string value;
+            value = getValue( line, "ShouldVisitTemplateInstantiations" );
+            if( value == "1" )
+                pluginInfo.shouldVisitTemplateInstantiations = true;
+            else
+            {
+                value = getValue( line, "ShouldVisitImplicitCode" );
+                if( value == "1" )
+                    pluginInfo.shouldVisitImplicitCode = true;
+                else
+                {
+                    std::cerr << "Unknown line " << line << std::endl;
+                    return false;
+                }
+            }
+        }
+    }
+
+    assert( endOk );
+    (void)endOk;
+
+    if( pluginInfo.shouldVisitTemplateInstantiations && pluginInfo.shouldVisitImplicitCode )
+        plugins[ PluginVisitTemplatesImplicit ].push_back( std::move( pluginInfo ));
+    else if( pluginInfo.shouldVisitTemplateInstantiations )
+        plugins[ PluginVisitTemplates ].push_back( std::move( pluginInfo ));
+    else if( pluginInfo.shouldVisitImplicitCode )
+        plugins[ PluginVisitImplicit ].push_back( std::move( pluginInfo ));
+    else
+        plugins[ PluginBasic ].push_back( std::move( pluginInfo ));
+
+    return true;
+}
+
+int main(int argc, char** argv)
+{
+    for( int i = 1 ; i < argc; ++i )
+    {
+        if( !readFile( argv[ i ] ))
+        {
+            std::cerr << "Error reading " << argv[ i ] << std::endl;
+            return 1;
+        }
+    }
+    for( int type = Plugin_Begin; type < Plugin_End; ++type )
+    {
+        sort( plugins[ static_cast< PluginType >( type ) ].begin(), plugins[ static_cast< PluginType >( type ) ].end(),
+            []( const PluginInfo& l, const PluginInfo& r ) { return l.className < r.className; } );
+    }
+    generate();
+    return 0;
+}