This file is indexed.

/usr/include/bobcat/pattern is in libbobcat-dev 4.08.02-2build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
#ifndef INCLUDED_BOBCAT_PATTERN_
#define INCLUDED_BOBCAT_PATTERN_

#include <string>
#include <utility>              // for pair<>
#include <regex.h>
#include <iostream>

//  match() throws an Errno when either the construction (i.e.,
//  compilation of the pattern) or the match failed.
//
//  The 0-index for position() or operator[] indicates the matched text,
//  other indices indicate subsequent subexpressions
//
//  Patterns may use:
//      \b - indicating a word-boundary
//      \d - indicating a digit
//      \D - indicating no digit
//      \s - indicating a white-space ([:space:]) char
//      \S - indicating no white-space ([:space:]) char
//
//  Pattern strings:
//
//      ------------------------------------------------------------
//      Required pattern        Provide Pattern()   Use as argument:
//                              internally with:
//      ------------------------------------------------------------
//      \\                      \\\\                \\\\\\\\       |
//      \d                      \d                  \\d            |
//      ------------------------------------------------------------

namespace FBB
{

class Pattern
{
    typedef std::pair<char const *, char const *> conversion;

    static conversion       s_patmod[];
    static size_t           s_sizeofPatmod;

    struct Regex
    {
        size_t              d_referenceCount;
        regex_t             d_regex;

        static std::string  s_converted;

        Regex(std::string pattern, int options);
        ~Regex();                                       // destructor.f

        private:
            Regex(Regex const &other) = delete;
            Regex &operator=(Regex const &other) = delete;
    };

    Regex                  *d_regex = 0;
    regmatch_t             *d_subExpression = 0;
    size_t                  d_nSub;
    size_t                  d_beyondLast;
    std::string             d_text;
    int                     d_matchOptions;

    public:
        typedef std::pair<std::string::size_type, std::string::size_type>
            Position;

        //  define a pattern using a case-flag and number of 
        //  ()-subexpressions. Compilation flags:
        //
        //  REG_EXTENDED
        //      Use POSIX Extended Regular Expression  syntax  when
        //      interpreting  regex.  If not set, POSIX Basic Regu­
        //      lar Expression syntax is used.
        //
        //  REG_NOSUB
        //      Support for substring addressing of matches is  not
        //      required.   The  nmatch  and  pmatch  parameters to
        //      regexec are ignored if the pattern buffer  supplied
        //      was compiled with this flag set.
        //
        //  REG_NEWLINE
        //      Match-any-character  operators  don't  match a new­
        //      line.
        //
        //      A non-matching list ([^...])  not containing a new­
        //      line does not match a newline.
        //
        //      Match-beginning-of-line  operator  (^)  matches the
        //      empty string immediately after a  newline,  regard­
        //      less  of  whether  eflags,  the  execution flags of
        //      regexec, contains REG_NOTBOL.
        //
        //      Match-end-of-line operator ($)  matches  the  empty
        //      string  immediately before a newline, regardless of
        //      whether eflags contains REG_NOTEOL.

        Pattern();                                      // 1

        Pattern(Pattern const &other);                  // 2.f

        explicit Pattern(std::string const &pattern,    // 3.cc
                        bool caseSensitive = true, 
                        size_t nSub = 10,
                        int options = REG_EXTENDED | REG_NEWLINE);
        Pattern(Pattern &&tmp);                         // 4
        ~Pattern();

        Pattern &operator=(Pattern const &other);
        Pattern &operator=(Pattern &&tmp);

        Pattern &operator<<(int matchOption);
        bool operator<<(std::string const &text);

        void setPattern(std::string const &pattern, 
                        bool caseSensitive = true, 
                        size_t nSub = 10,
                        int options = REG_EXTENDED | REG_NEWLINE);

        //  match a string with a pattern. true: string matched
        //  options could be:
        //
        //  REG_NOTBOL
        //      The  match-beginning-of-line  operator always fails
        //      to match (but see the compilation flag  REG_NEWLINE
        //      above)  This  flag  may be used when different por­
        //      tions of a string are passed  to  regexec  and  the
        //      beginning  of  the string should not be interpreted
        //      as the beginning of the line.
        //
        //  REG_NOTEOL
        //      The  match-end-of-line  operator  always  fails  to
        //      match  (but  see  the  compilation flag REG_NEWLINE)

        void match(std::string const &text, int options = 0);

        std::string before() const;  // text before the matched text
        std::string matched() const;   // the matched text              .f
        std::string beyond() const;  // text beyond the matched text

            // (0) is complete matching part. Remaining are subexpressions.
            // (npos, npos) is returned if index exceeds available indices
            // (which may be 0)

            // position of subexpression
        Position position(size_t index) const; 

            // subexpression itself
        std::string operator[](size_t index) const; 
        size_t end() const;           // index beyond the last available    .f

        std::string const &pattern() const; // compiled pattern

        void swap(Pattern &other);

    private:
        void newRegex(std::string const &pattern, int options);         // .f
        void destroy();
        void copy(Pattern const &other);    
};

inline Pattern::Pattern(Pattern const &other)
{
    copy(other);
}
inline std::string Pattern::matched() const 
{
    return (*this)[0];
}
inline std::string const &Pattern::pattern() const 
{
    return Regex::s_converted;
}
inline size_t Pattern::end() const
{
    return d_beyondLast;
}

} // FBB

#endif