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 <sstream>
#include <string_view>
#include <vector>
 
#include "cstring.h"
#include "stringify.h"
 
// GTest
#ifdef P4C_GTEST_ENABLED
#include "gtest/gtest_prod.h"
#endif
 
namespace P4::Test {
class UtilSourceFile;
}
 
namespace P4::Util {
using namespace P4::literals;
 
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 = ""_cs;
    int line = -1;
    int column = -1;
    cstring srcBrief = ""_cs;
    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 toString() const;
 
    void dbprint(std::ostream &out) const { out << this->toString(); }
 
    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); }
 
    friend std::ostream &operator<<(std::ostream &os, const SourceInfo &info);
 
 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() {}
};

template <class, class = void>
struct has_SourceInfo : std::false_type {};
 
template <class T>
struct has_SourceInfo<T, std::void_t<decltype(std::declval<T>().getSourceInfo())>>
    : std::true_type {};
 
template <class T>
inline constexpr bool has_SourceInfo_v = has_SourceInfo<T>::value;

struct SourceFileLine {
    cstring fileName;
    unsigned sourceLine;
 
    SourceFileLine(std::string_view 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::stringstream str;
        dbprint(str);
        return str.str();
    }
    void dbprint(std::ostream &out) const override {
        if (singleLine)
            out << "//";
        else
            out << "/*";
        out << body;
        if (!singleLine) out << "*/";
    }
};

class InputSources final {
#ifdef P4C_GTEST_ENABLED
    FRIEND_TEST(UtilSourceFile, InputSources);
#endif
 
 public:
    InputSources();
 
    std::string_view 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(std::string_view 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 P4::Util
 
namespace P4 {
 
void dbprint(const IHasDbPrint *o);
 
}  // namespace P4
 
#endif /* LIB_SOURCE_FILE_H_ */