master_lexer_inputsource.h 5.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Copyright (C) 2012  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#ifndef DNS_INPUTSOURCE_H
#define DNS_INPUTSOURCE_H 1

18
19
#include <exceptions/exceptions.h>

20
#include <iostream>
21
#include <fstream>
22
23
24
25
26
27
28
#include <string>
#include <vector>

namespace isc {
namespace dns {
namespace master_lexer_internal {

29
30
31
32
33
34
35
36
37
/// \brief An input source that is used internally by MasterLexer.
///
/// This is a helper internal class for MasterLexer, and represents
/// state of a single source of the entire zone data to be
/// parsed. Normally this means the master zone file, but MasterLexer
/// can have multiple InputSources if $INCLUDE is used. The source can
/// also be generic input stream (std::istream).
///
/// This class is not meant for public use.
38
39
class InputSource {
public:
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
    /// \brief Returned by getChar() when end of stream is reached.
    static const int END_OF_STREAM;

    /// \brief Exception thrown when ungetChar() is made to go before
    /// the start of buffer.
    struct UngetBeforeBeginning : public OutOfRange {
        UngetBeforeBeginning(const char* file, size_t line, const char* what) :
            OutOfRange(file, line, what)
        {}
    };

    /// \brief Exception thrown when we fail to read from the input
    /// stream or file.
    struct ReadError : public Unexpected {
        ReadError(const char* file, size_t line, const char* what) :
            Unexpected(file, line, what)
        {}
    };

    /// \brief Exception thrown when we fail to open the input file.
    struct OpenError : public Unexpected {
        OpenError(const char* file, size_t line, const char* what) :
            Unexpected(file, line, what)
        {}
    };

66
67
    /// \brief Constructor which takes an input stream. The stream is
    /// read-from, but it is not closed.
68
    explicit InputSource(std::istream& input_stream);
69
70
71

    /// \brief Constructor which takes a filename to read from. The
    /// associated file stream is managed internally.
72
73
    ///
    /// \throws OpenError when opening the input file fails.
74
    explicit InputSource(const char* filename);
75

76
    /// \brief Destructor
77
78
    ~InputSource();

79
80
81
    /// \brief Returns a name for the InputSource. Typically this is the
    /// filename, but if the InputSource was constructed for an
    /// \c std::istream, it returns a name in the format "stream-%p".
82
    const std::string& getName() const {
83
84
85
        return (name_);
    }

86
    /// \brief Returns if the input source is at end of file.
87
88
89
90
    bool atEOF() const {
        return (at_eof_);
    }

91
    /// \brief Returns the current line number being read.
92
93
94
95
    size_t getCurrentLine() const {
        return (line_);
    }

96
97
    /// \brief Saves the current line being read. Later, when
    /// \c ungetAll() is called, it skips back to the last-saved line.
98
99
100
101
    ///
    /// TODO: Please make this method private if it is unused after the
    /// MasterLexer implementation is complete (and only \c mark() is
    /// used instead).
102
103
104
105
106
    void saveLine();

    /// Removes buffered content before the current location in the
    /// \c InputSource. It's not possible to \c ungetChar() after this,
    /// unless we read more data using \c getChar().
107
108
109
110
    ///
    /// TODO: Please make this method private if it is unused after the
    /// MasterLexer implementation is complete (and only \c mark() is
    /// used instead).
111
112
113
114
    void compact();

    /// Calls \c saveLine() and \c compact() in sequence.
    void mark();
115

116
    /// \brief Returns a single character from the input source. If end
117
    /// of file is reached, \c END_OF_STREAM is returned.
118
119
120
    ///
    /// \throws ReadError when reading from the input stream or file
    /// fails.
121
    int getChar();
122
123
124

    /// \brief Skips backward a single character in the input
    /// source. The last-read character is unget.
125
126
127
128
    ///
    /// \throws UngetBeforeBeginning if we go backwards past the start
    /// of reading, or backwards past the last time compact() was
    /// called.
129
    void ungetChar();
130

131
132
133
134
135
    /// Forgets what was read, and skips back to the position where
    /// \c compact() was last called. If \c compact() was not called, it
    /// skips back to where reading started. If \c saveLine() was called
    /// previously, it sets the current line number to the line number
    /// saved.
136
137
138
139
140
141
142
143
144
    void ungetAll();

private:
    bool at_eof_;
    size_t line_;
    size_t saved_line_;

    std::vector<char> buffer_;
    size_t buffer_pos_;
145

Mukund Sivaraman's avatar
Mukund Sivaraman committed
146
    const std::string name_;
147
    std::ifstream file_stream_;
148
    std::istream& input_;
149
150
};

151
152
const int InputSource::END_OF_STREAM = -1;

153
154
155
156
157
158
159
160
161
} // namespace master_lexer_internal
} // namespace dns
} // namespace isc

#endif  // DNS_INPUTSOURCE_H

// Local Variables:
// mode: c++
// End: