Lint Metrics & ALOA
by Ralf Holly




Listing 1:

// Encapsulates a lint issue (ie. warning, error)
class Issue {
public:
    Issue(int number, int severity) : 
        m_number(number), 
        m_severity(severity),
        m_count(0) {} 
    // Register a file with this issue
    void addFile(const File* pFile) {
        assert(pFile != NULL); 
        m_files.push_back(pFile);
        ++m_count;
    }
    int getNumber() const       { return m_number;   }
    int getSeverity() const     { return m_severity; }
    int getCount() const        { return m_count;    }
private:
    friend bool operator<(const Issue& lhs, const Issue& rhs);
    typedef std::vector<const File*> FileList;
    int m_number;         // Lint issue number
    int m_severity;       // The severity level of this lint issue
    int m_count;          // Total number of occurrences of this lint issue
    FileList m_files;     // List of all files that contain this lint issue
};
// Encapsulates a source code file with possibly many lint issues
class File {
public:
    File(const std::string& filename) :
        m_filename(filename),
        m_severityScore(0),
        m_severestIssueNumber(UNUSED_ISSUE_NUMBER) {}
    // Registers a lint issue with this file
    void addIssue(const Issue* pIssue) {
        assert(pIssue != NULL);
        m_issues.push_back(pIssue);
        int issueNumber = pIssue->getNumber();
        int severity = getSeverity(issueNumber);
        if (   m_severestIssueNumber == UNUSED_ISSUE_NUMBER 
            || severity > getSeverity(m_severestIssueNumber) ) {
            m_severestIssueNumber = issueNumber;
        }
        m_severityScore += severity;    
    }
    const std::string& getFilename() const   { return m_filename;            }
    int getSeverityScore() const             { return m_severityScore;       } 
    int getSeverestIssueNumber() const       { return m_severestIssueNumber; }
private:
    friend bool operator<(const File& lhs, const File& rhs);
    typedef std::vector<const Issue*> IssueList;
    std::string m_filename;     // The name of this source code module
    int m_severityScore;        // The accumulated severity score
    int m_severestIssueNumber;  // The issue number with the highest severity
    IssueList m_issues;     // List of all Lint issues contained in this file
};


Listing 2:

static void onNewIssueHandler(const char* pFilename, int number) {
    int severity = getSeverity(number);
    // Update global metrics
    ++gIssuesCount;
    gSeverityScore += severity;
    // Obtain file object
    string filename(pFilename);
    File* pFile = 0;
    FILE_MAP::iterator iterFile = gFileMap.find(filename);
    
    // If unknown filename, create new file object
    if (iterFile == gFileMap.end()) {
        pFile = new File(filename);
        bool wasInserted = gFileMap.insert(make_pair(filename, pFile)).second;
        assert(wasInserted);
    // If known filename, retrieve existing file object
    } else {
        pFile = (*iterFile).second;
    }
    // Obtain issue object  
    Issue* pIssue = 0;
    ISSUE_MAP::iterator iterIssue = gIssueMap.find(number);
    // If unknown issue, create new issue object
    if (iterIssue == gIssueMap.end()) {
        pIssue = new Issue(number, severity);
        bool wasInserted = gIssueMap.insert(make_pair(number, pIssue)).second;
        assert(wasInserted);
    // If known issue, retrieve existing issue object
    } else {
        pIssue = (*iterIssue).second;
    }
    // Update file/issue metrics
    pFile->addIssue(pIssue);
    pIssue->addFile(pFile);
}
static void buildMetricsLists() {
    // Create sorted file list
    FILE_MAP::iterator iterFile = gFileMap.begin();
    for (; iterFile != gFileMap.end(); ++iterFile) {
        gFileList.push_back(*(*iterFile).second);
    }
    sort(gFileList.begin(), gFileList.end());
    // Create sorted issue list 
    ISSUE_MAP::iterator iterIssue = gIssueMap.begin();
    for (; iterIssue != gIssueMap.end(); ++iterIssue) {
        gIssueList.push_back(*(*iterIssue).second);
    }
    sort(gIssueList.begin(), gIssueList.end());
}
int main(int argc, const char* const argv[]) {
    try {
        initGlobals();
        scanCommandLine(argc, argv);
        parseLintOutputFile(gpLintOutputFile, &onNewIssueHandler);
        buildMetricsLists();
        reportMetrics();
    } catch (const ParseFileNotFoundError& e) {
        reportFatalError("Cannot access " + e.getFilename());
    } catch (const ParseMalformedLineError& e) {
        ostringstream s;
        s << "Malformed file: " << e.getFilename() << ", 
                                          line: " << e.getLineNo();
        reportFatalError(s.str());
    } catch (...) {
        reportFatalError("Unspecified fatal error");        
    }
    return EXIT_SUCCESS;
}






3