Welcome to the NetCologne GmbH open source mirroring service!

This machine mirrors various open-source projects. 20 Gbit/s uplink.

If there are any issues or you want another project mirrored, please contact mirror-service -=AT=- netcologne DOT de !

include/comma/basic/TextProvider.h

Go to the documentation of this file.

//===-- basic/TextProvider.h ---------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_BASIC_TEXTPROVIDER_HDR_GUARD
#define COMMA_BASIC_TEXTPROVIDER_HDR_GUARD

#include "comma/basic/Location.h"
#include "llvm/System/Path.h"
#include "llvm/Support/MemoryBuffer.h"
#include <string>
#include <vector>

namespace comma {

class TextIterator {
public:

    TextIterator(const TextIterator &ti)
        : cursor(ti.cursor)
        { }

    TextIterator &operator=(const TextIterator &ti) {
        cursor = ti.cursor;
        return *this;
    }

    bool operator==(const TextIterator &ti) const {
        return cursor == ti.cursor;
    }

    bool operator!=(const TextIterator &ti) const {
        return cursor != ti.cursor;
    }

    TextIterator &operator++() {
        ++cursor;
        return *this;
    }

    TextIterator operator++(int) {
        TextIterator prev(*this);
        ++cursor;
        return prev;
    }

    TextIterator &operator--() {
        --cursor;
        return *this;
    }

    TextIterator operator--(int) {
        TextIterator copy(*this);
        --cursor;
        return copy;
    }

    unsigned operator*() const {
        return *cursor;
    }

    const char *operator&() const {
        return cursor;
    }

private:
    friend class TextProvider;

    TextIterator(const char *c) : cursor(c) { }

    const char *cursor;
};

class TextProvider {

public:
    TextProvider(const llvm::sys::Path& path);

    TextProvider(const char *buffer, size_t size);

    TextProvider(const std::string &string);

    ~TextProvider();

    std::string getIdentity() const { return identity; }

    Location getLocation(const TextIterator &ti) const;

    SourceLocation getSourceLocation(const TextIterator &ti) const;

    SourceLocation getSourceLocation(const Location loc) const;

    unsigned getLine(Location) const;

    unsigned getColumn(Location) const;

    unsigned getLine(const TextIterator &ti) const {
        return getLine(getLocation(ti));
    }

    unsigned getColumn(const TextIterator &ti) const {
        return getColumn(getLocation(ti));
    }

    TextIterator begin() const;

    TextIterator end() const;

    std::string extract(Location start, Location end) const;

    std::string extract(const TextIterator &iter,
                        const TextIterator &endIter) const;

    std::string extract(const SourceLocation &sloc) const;

    unsigned extract(const TextIterator &iter,
                     const TextIterator &endIter,
                     char *buffer, size_t size) const;

private:
    friend class TextIterator;

    // Disallow copy and assignment.
    TextProvider(const TextProvider&);
    TextProvider &operator=(const TextProvider&);

    unsigned indexOf(const char *ptr) const {
        return ptr - buffer;
    }

    std::pair<unsigned, unsigned> getLineOf(Location loc) const;

    std::string identity;

    llvm::MemoryBuffer *memBuffer;

    const char *buffer;

    mutable std::vector<unsigned> lines;

    void initializeLinevec();

    mutable unsigned maxLineIndex;
};

} // End comma namespace.

#endif

---