source_file.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
/* -*-c++-*- */
 
/* Source-level information for a P4 program */
 
#ifndef LIB_SOURCE_FILE_H_
#define LIB_SOURCE_FILE_H_
 
#include <map>
#include <vector>
 
#include "cstring.h"
 
// GTest
#ifdef P4C_GTEST_ENABLED
#include "gtest/gtest_prod.h"
#endif
 
namespace Test {
class UtilSourceFile;
}
 
class IHasDbPrint {
 public:
    virtual void dbprint(std::ostream &out) const = 0;
    void print() const;  // useful in the debugger
    virtual ~IHasDbPrint() = default;
};
 
namespace Util {
struct SourceFileLine;
class SourcePosition final {
 public:
    SourcePosition() = default;
 
    SourcePosition(unsigned lineNumber, unsigned columnNumber);
 
    SourcePosition(const SourcePosition &other) = default;
    SourcePosition &operator=(const SourcePosition &) = default;
 
    inline bool operator==(const SourcePosition &rhs) const {
        return columnNumber == rhs.columnNumber && lineNumber == rhs.lineNumber;
    }
    inline bool operator!=(const SourcePosition &rhs) const { return !this->operator==(rhs); }
 
    inline bool operator<(const SourcePosition &rhs) const {
        return (lineNumber < rhs.lineNumber) ||
               (lineNumber == rhs.lineNumber && columnNumber < rhs.columnNumber);
    }
    inline bool operator>(const SourcePosition &rhs) const { return rhs.operator<(*this); }
    inline bool operator<=(const SourcePosition &rhs) const { return !this->operator>(rhs); }
    inline bool operator>=(const SourcePosition &rhs) const { return !this->operator<(rhs); }
 
    SourcePosition &operator--() {
        if (columnNumber > 0) columnNumber--;
        return *this;
    }
    SourcePosition operator--(int) {
        SourcePosition tmp(*this);
        this->operator--();
        return tmp;
    }
 
    inline const SourcePosition &min(const SourcePosition &rhs) const {
        if (this->operator<(rhs)) return *this;
        return rhs;
    }
 
    inline const SourcePosition &max(const SourcePosition &rhs) const {
        if (this->operator>(rhs)) return *this;
        return rhs;
    }
 
    cstring toString() const;
 
    bool isValid() const { return lineNumber != 0; }
 
    unsigned getLineNumber() const { return lineNumber; }
 
    unsigned getColumnNumber() const { return columnNumber; }
 
 private:
    // Input sources where this character position is interpreted.
    unsigned lineNumber = 0;
    unsigned columnNumber = 0;
};
 
class InputSources;
 
class SourceInfo final {
 public:
    cstring filename = "";
    int line = -1;
    int column = -1;
    cstring srcBrief = "";
    SourceInfo(cstring filename, int line, int column, cstring srcBrief) {
        this->filename = filename;
        this->line = line;
        this->column = column;
        this->srcBrief = srcBrief;
    }
    SourceInfo() = default;
 
    SourceInfo(const InputSources *sources, SourcePosition point)
        : sources(sources), start(point), end(point) {}
 
    SourceInfo(const InputSources *sources, SourcePosition start, SourcePosition end);
 
    SourceInfo(const SourceInfo &other) = default;
    SourceInfo &operator=(const SourceInfo &other) = default;
    ~SourceInfo() = default;
 
    SourceInfo operator+(const SourceInfo &rhs) const {
        if (!this->isValid()) return rhs;
        if (!rhs.isValid()) return *this;
        SourcePosition s = start.min(rhs.start);
        SourcePosition e = end.max(rhs.end);
        return SourceInfo(sources, s, e);
    }
    SourceInfo &operator+=(const SourceInfo &rhs) {
        if (!isValid()) {
            *this = rhs;
        } else if (rhs.isValid()) {
            start = start.min(rhs.start);
            end = end.max(rhs.end);
        }
        return *this;
    }
 
    bool operator==(const SourceInfo &rhs) const { return start == rhs.start && end == rhs.end; }
 
    cstring toDebugString() const;
 
    void dbprint(std::ostream &out) const { out << this->toDebugString(); }
 
    cstring toSourceFragment(bool useMarker = true) const;
    cstring toBriefSourceFragment() const;
    cstring toPositionString() const;
    cstring toSourcePositionData(unsigned *outLineNumber, unsigned *outColumnNumber) const;
    SourceFileLine toPosition() const;
 
    bool isValid() const { return this->start.isValid(); }
    explicit operator bool() const { return isValid(); }
 
    cstring getSourceFile() const;
    cstring getLineNum() const;
 
    const SourcePosition &getStart() const { return this->start; }
 
    const SourcePosition &getEnd() const { return this->end; }
 
    bool operator<(const SourceInfo &rhs) const {
        if (!rhs.isValid()) return false;
        if (!isValid()) return true;
        return this->start < rhs.start;
    }
    inline bool operator>(const SourceInfo &rhs) const { return rhs.operator<(*this); }
    inline bool operator<=(const SourceInfo &rhs) const { return !this->operator>(rhs); }
    inline bool operator>=(const SourceInfo &rhs) const { return !this->operator<(rhs); }
 
 private:
    const InputSources *sources = nullptr;
    SourcePosition start = SourcePosition();
    SourcePosition end = SourcePosition();
};
 
class IHasSourceInfo {
 public:
    virtual SourceInfo getSourceInfo() const = 0;
    virtual cstring toString() const = 0;
    virtual ~IHasSourceInfo() {}
};
 
struct SourceFileLine {
    cstring fileName;
    unsigned sourceLine;
 
    SourceFileLine(cstring file, unsigned line) : fileName(file), sourceLine(line) {}
 
    cstring toString() const;
};
 
class Comment final : IHasDbPrint {
 private:
    SourceInfo srcInfo;
    bool singleLine;
    cstring body;
 
 public:
    Comment(SourceInfo srcInfo, bool singleLine, cstring body)
        : srcInfo(srcInfo), singleLine(singleLine), body(body) {}
    cstring toString() const {
        std::string result;
        if (singleLine)
            result = "//";
        else
            result = "/*";
        result += body;
        if (!singleLine) result += "*/";
        return result;
    }
    void dbprint(std::ostream &out) const { out << toString(); }
};
 
class InputSources final {
#ifdef P4C_GTEST_ENABLED
    FRIEND_TEST(UtilSourceFile, InputSources);
#endif
 
 public:
    InputSources();
 
    cstring getLine(unsigned lineNumber) const;
    SourceFileLine getSourceLine(unsigned line) const;
 
    unsigned lineCount() const;
    SourcePosition getCurrentPosition() const;
    unsigned getCurrentLineNumber() const;
 
    void seal();
 
    void appendText(const char *text);
 
    void mapLine(cstring file, unsigned originalSourceLineNo);
 
    cstring getSourceFragment(const SourcePosition &position, bool useMarker) const;
    cstring getSourceFragment(const SourceInfo &position, bool useMarker) const;
    cstring getBriefSourceFragment(const SourceInfo &position) const;
 
    cstring toDebugString() const;
    void addComment(SourceInfo srcInfo, bool singleLine, cstring body);
 
 private:
    void appendToLastLine(std::string_view text);
    void appendNewline(std::string_view newline);
 
    bool sealed;
 
    std::map<unsigned, SourceFileLine> line_file_map;
 
    std::vector<std::string> contents;
    std::vector<Comment *> comments;
};
 
}  // namespace Util
 
void dbprint(const IHasDbPrint *o);
 
#endif /* LIB_SOURCE_FILE_H_ */