This file is indexed.

/usr/include/bobcat/processenums is in libbobcat-dev 3.19.01-1ubuntu1.

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


namespace FBB
{

struct ProcessEnums
{
    enum ChildOutput
    {
        NOTHING_AVAILABLE   = 0,
        CHILD_COUT          = 1 << 0,
        CHILD_CERR          = 1 << 1,
    };

    enum IOMode: size_t
    {
        NONE                = 0,        // no piping/redirection
        STD                 = NONE,     // for backward compatibility reasons

        CIN             	= 1 << 0,
        COUT            	= 1 << 1,
        CERR            	= 1 << 2,
        ALL                 = CIN | COUT | CERR,
                        	
        IGNORE_COUT     	= 1 << 3,
        IGNORE_CERR     	= 1 << 4,
        IGNORE_COUT_CERR    = IGNORE_COUT |	 IGNORE_CERR,

        MERGE_COUT_CERR 	= 1 << 5,
                        	
        DIRECT          	= 1 << 8,
    };

    protected:
        static IOMode iomode(size_t mode);

        enum IOModeExt
        {
            ALL_IOMODES     = (1 << 9) - 1,

            IN_PIPE         = 1 << 10,
            OUT_PIPE        = 1 << 11,

            CLOSE_ON_EXEC   = 1 << 12,
            PIPES_OK        = 1 << 13
        };
        friend IOMode operator|(IOMode lhs, IOModeExt rhs);
        friend IOMode operator|(IOModeExt lhs, IOModeExt rhs);
        friend IOMode &operator|=(IOMode &lhs, IOModeExt rhs);

        enum ChildAction
        {
            TIME_LIMIT,
            CHILD_ENDED
        };
};

inline ProcessEnums::ChildOutput operator|(ProcessEnums::ChildOutput lhs, 
                                      ProcessEnums::ChildOutput rhs)
{
    return static_cast<ProcessEnums::ChildOutput>(
            static_cast<size_t>(lhs) | static_cast<size_t>(rhs));
}

inline bool operator&(ProcessEnums::ChildOutput lhs, 
                                      ProcessEnums::ChildOutput rhs)
{
    return static_cast<size_t>(lhs) & static_cast<size_t>(rhs);
}

inline ProcessEnums::IOMode ProcessEnums::iomode(size_t mode)
{
    return static_cast<IOMode>(mode & ALL_IOMODES);
}


inline ProcessEnums::IOMode operator|(ProcessEnums::IOMode lhs, 
                                      ProcessEnums::IOMode rhs)
{
    return static_cast<ProcessEnums::IOMode>(
            static_cast<size_t>(lhs) | static_cast<size_t>(rhs));
}


inline ProcessEnums::IOMode operator|(ProcessEnums::IOMode lhs, 
                                      ProcessEnums::IOModeExt rhs)
{
    return static_cast<ProcessEnums::IOMode>(
            static_cast<size_t>(lhs) | static_cast<size_t>(rhs));
}


inline ProcessEnums::IOMode operator|(ProcessEnums::IOModeExt lhs, 
                                      ProcessEnums::IOModeExt rhs)
{
    return static_cast<ProcessEnums::IOMode>(
            static_cast<size_t>(lhs) | static_cast<size_t>(rhs));
}

inline ProcessEnums::IOMode operator&(ProcessEnums::IOMode lhs, 
                                      ProcessEnums::IOMode rhs)
{
    return static_cast<ProcessEnums::IOMode>(
            static_cast<size_t>(lhs) & static_cast<size_t>(rhs));
}

inline ProcessEnums::IOMode operator~(ProcessEnums::IOMode mode)
{
    return static_cast<ProcessEnums::IOMode>(~static_cast<size_t>(mode));
}

inline ProcessEnums::IOMode &operator|=(ProcessEnums::IOMode &lhs, 
                                       ProcessEnums::IOMode rhs)
{
    reinterpret_cast<size_t &>(lhs) |= static_cast<size_t>(rhs);
    return lhs;
}

inline ProcessEnums::IOMode &operator|=(ProcessEnums::IOMode &lhs, 
                                       ProcessEnums::IOModeExt rhs)
{
    reinterpret_cast<size_t &>(lhs) |= static_cast<size_t>(rhs);
    return lhs;
}

} // FBB        
#endif