summaryrefslogtreecommitdiff
path: root/src/mongo/db/cst/location_gen.h
blob: c6549fdadbfd490caa0f2248f4450bec1e5d0075 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
// A Bison parser, made by GNU Bison 3.6.3.

// Locations for Bison parsers in C++

// Copyright (C) 2002-2015, 2018-2020 Free Software Foundation, Inc.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// As a special exception, you may create a larger work that contains
// part or all of the Bison parser skeleton and distribute that work
// under terms of your choice, so long as that work isn't itself a
// parser generator using the skeleton or a modified version thereof
// as a parser skeleton.  Alternatively, if you modify or redistribute
// the parser skeleton itself, you may (at your option) remove this
// special exception, which will cause the skeleton and the resulting
// Bison output files to be licensed under the GNU General Public
// License without this special exception.

// This special exception was added by the Free Software Foundation in
// version 2.2 of Bison.

/**
 ** \file location_gen.h
 ** Define the mongo::location class.
 */

#ifndef YY_YY_LOCATION_GEN_H_INCLUDED
#define YY_YY_LOCATION_GEN_H_INCLUDED

#include <iostream>
#include <string>

#ifndef YY_NULLPTR
#if defined __cplusplus
#if 201103L <= __cplusplus
#define YY_NULLPTR nullptr
#else
#define YY_NULLPTR 0
#endif
#else
#define YY_NULLPTR ((void*)0)
#endif
#endif

#line 58 "pipeline_grammar.yy"
namespace mongo {
#line 59 "location_gen.h"

/// A point in a source file.
class position {
public:
    /// Type for line and column numbers.
    typedef int counter_type;

    /// Construct a position.
    explicit position(std::string* f = YY_NULLPTR, counter_type l = 1, counter_type c = 1)
        : filename(f), line(l), column(c) {}


    /// Initialization.
    void initialize(std::string* fn = YY_NULLPTR, counter_type l = 1, counter_type c = 1) {
        filename = fn;
        line = l;
        column = c;
    }

    /** \name Line and Column related manipulators
     ** \{ */
    /// (line related) Advance to the COUNT next lines.
    void lines(counter_type count = 1) {
        if (count) {
            column = 1;
            line = add_(line, count, 1);
        }
    }

    /// (column related) Advance to the COUNT next columns.
    void columns(counter_type count = 1) {
        column = add_(column, count, 1);
    }
    /** \} */

    /// File name to which this position refers.
    std::string* filename;
    /// Current line number.
    counter_type line;
    /// Current column number.
    counter_type column;

private:
    /// Compute max (min, lhs+rhs).
    static counter_type add_(counter_type lhs, counter_type rhs, counter_type min) {
        return lhs + rhs < min ? min : lhs + rhs;
    }
};

/// Add \a width columns, in place.
inline position& operator+=(position& res, position::counter_type width) {
    res.columns(width);
    return res;
}

/// Add \a width columns.
inline position operator+(position res, position::counter_type width) {
    return res += width;
}

/// Subtract \a width columns, in place.
inline position& operator-=(position& res, position::counter_type width) {
    return res += -width;
}

/// Subtract \a width columns.
inline position operator-(position res, position::counter_type width) {
    return res -= width;
}

/// Compare two position objects.
inline bool operator==(const position& pos1, const position& pos2) {
    return (pos1.line == pos2.line && pos1.column == pos2.column &&
            (pos1.filename == pos2.filename ||
             (pos1.filename && pos2.filename && *pos1.filename == *pos2.filename)));
}

/// Compare two position objects.
inline bool operator!=(const position& pos1, const position& pos2) {
    return !(pos1 == pos2);
}

/** \brief Intercept output stream redirection.
 ** \param ostr the destination output stream
 ** \param pos a reference to the position to redirect
 */
template <typename YYChar>
std::basic_ostream<YYChar>& operator<<(std::basic_ostream<YYChar>& ostr, const position& pos) {
    if (pos.filename)
        ostr << *pos.filename << ':';
    return ostr << pos.line << '.' << pos.column;
}

/// Two points in a source file.
class location {
public:
    /// Type for line and column numbers.
    typedef position::counter_type counter_type;

    /// Construct a location from \a b to \a e.
    location(const position& b, const position& e) : begin(b), end(e) {}

    /// Construct a 0-width location in \a p.
    explicit location(const position& p = position()) : begin(p), end(p) {}

    /// Construct a 0-width location in \a f, \a l, \a c.
    explicit location(std::string* f, counter_type l = 1, counter_type c = 1)
        : begin(f, l, c), end(f, l, c) {}


    /// Initialization.
    void initialize(std::string* f = YY_NULLPTR, counter_type l = 1, counter_type c = 1) {
        begin.initialize(f, l, c);
        end = begin;
    }

    /** \name Line and Column related manipulators
     ** \{ */
public:
    /// Reset initial location to final location.
    void step() {
        begin = end;
    }

    /// Extend the current location to the COUNT next columns.
    void columns(counter_type count = 1) {
        end += count;
    }

    /// Extend the current location to the COUNT next lines.
    void lines(counter_type count = 1) {
        end.lines(count);
    }
    /** \} */


public:
    /// Beginning of the located region.
    position begin;
    /// End of the located region.
    position end;
};

/// Join two locations, in place.
inline location& operator+=(location& res, const location& end) {
    res.end = end.end;
    return res;
}

/// Join two locations.
inline location operator+(location res, const location& end) {
    return res += end;
}

/// Add \a width columns to the end position, in place.
inline location& operator+=(location& res, location::counter_type width) {
    res.columns(width);
    return res;
}

/// Add \a width columns to the end position.
inline location operator+(location res, location::counter_type width) {
    return res += width;
}

/// Subtract \a width columns to the end position, in place.
inline location& operator-=(location& res, location::counter_type width) {
    return res += -width;
}

/// Subtract \a width columns to the end position.
inline location operator-(location res, location::counter_type width) {
    return res -= width;
}

/// Compare two location objects.
inline bool operator==(const location& loc1, const location& loc2) {
    return loc1.begin == loc2.begin && loc1.end == loc2.end;
}

/// Compare two location objects.
inline bool operator!=(const location& loc1, const location& loc2) {
    return !(loc1 == loc2);
}

/** \brief Intercept output stream redirection.
 ** \param ostr the destination output stream
 ** \param loc a reference to the location to redirect
 **
 ** Avoid duplicate information.
 */
template <typename YYChar>
std::basic_ostream<YYChar>& operator<<(std::basic_ostream<YYChar>& ostr, const location& loc) {
    location::counter_type end_col = 0 < loc.end.column ? loc.end.column - 1 : 0;
    ostr << loc.begin;
    if (loc.end.filename && (!loc.begin.filename || *loc.begin.filename != *loc.end.filename))
        ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col;
    else if (loc.begin.line < loc.end.line)
        ostr << '-' << loc.end.line << '.' << end_col;
    else if (loc.begin.column < end_col)
        ostr << '-' << end_col;
    return ostr;
}

#line 58 "pipeline_grammar.yy"
}  // namespace mongo
#line 333 "location_gen.h"

#endif  // !YY_YY_LOCATION_GEN_H_INCLUDED