This file is indexed.

/usr/include/ns3/int64x64.h is in libns3-dev 3.13+dfsg-1.

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

#include "ns3/core-config.h"

#if defined (INT64X64_USE_DOUBLE) || defined (PYTHON_SCAN)
#include "int64x64-double.h"
#elif defined (INT64X64_USE_CAIRO)
#include "int64x64-cairo.h"
#elif defined (INT64X64_USE_128)
#include "int64x64-128.h"
#endif

#include <iostream>

namespace ns3 {

#define INT64X64_OP_ARITH_TYPE(op,type)                                 \
  inline int64x64_t operator op (const int64x64_t &lhs, const type rhs) \
  {                                                                     \
    int64x64_t tmp = lhs;                                               \
    tmp op ## = int64x64_t (rhs);                                         \
    return tmp;                                                         \
  }                                                                     \
  inline int64x64_t operator op (const type lhs, const int64x64_t &rhs) \
  {                                                                     \
    int64x64_t tmp = int64x64_t (lhs);                                  \
    tmp op ## = rhs;                                                      \
    return tmp;                                                         \
  }

#define INT64X64_OP_ARITH(op)                                           \
  inline int64x64_t operator op (const int64x64_t &lhs, const int64x64_t &rhs) \
  {                                                                     \
    int64x64_t tmp = lhs;                                               \
    tmp op ## = rhs;                                                      \
    return tmp;                                                         \
  }                                                                     \
  INT64X64_OP_ARITH_TYPE (op,double)                                     \
  INT64X64_OP_ARITH_TYPE (op,signed char)                              \
  INT64X64_OP_ARITH_TYPE (op,signed short)                             \
  INT64X64_OP_ARITH_TYPE (op,signed int)                               \
  INT64X64_OP_ARITH_TYPE (op,signed long int)                          \
  INT64X64_OP_ARITH_TYPE (op,signed long long int)                     \
  INT64X64_OP_ARITH_TYPE (op,unsigned char)                            \
  INT64X64_OP_ARITH_TYPE (op,unsigned short)                           \
  INT64X64_OP_ARITH_TYPE (op,unsigned int)                             \
  INT64X64_OP_ARITH_TYPE (op,unsigned long int)                        \
  INT64X64_OP_ARITH_TYPE (op,unsigned long long int)

#define INT64X64_OP_CMP_TYPE(op,type)                                   \
  inline bool operator op (const int64x64_t &lhs, const type &rhs)      \
  {                                                                     \
    return lhs op int64x64_t (rhs);                                     \
  }                                                                     \
  inline bool operator op (const type &lhs, const int64x64_t &rhs)      \
  {                                                                     \
    return int64x64_t (lhs) op rhs;                                     \
  }

#define INT64X64_OP_CMP(op)                                             \
  INT64X64_OP_CMP_TYPE (op,double)                                       \
  INT64X64_OP_CMP_TYPE (op,signed int)                                 \
  INT64X64_OP_CMP_TYPE (op,signed long int)                            \
  INT64X64_OP_CMP_TYPE (op,signed long long int)                       \
  INT64X64_OP_CMP_TYPE (op,unsigned int)                               \
  INT64X64_OP_CMP_TYPE (op,unsigned long int)                          \
  INT64X64_OP_CMP_TYPE (op,unsigned long long int)


INT64X64_OP_ARITH (+)
INT64X64_OP_ARITH (-)
INT64X64_OP_ARITH (*)
INT64X64_OP_ARITH (/)
INT64X64_OP_CMP (==)
INT64X64_OP_CMP (!=)
INT64X64_OP_CMP (<)
INT64X64_OP_CMP (<=)
INT64X64_OP_CMP (>)
INT64X64_OP_CMP (>=)

std::ostream &operator << (std::ostream &os, const int64x64_t &val);
std::istream &operator >> (std::istream &is, int64x64_t &val);

inline int64x64_t Abs (const int64x64_t &value)
{
  return (value < 0) ? -value : value;
}

inline int64x64_t Min (const int64x64_t &a, const int64x64_t &b)
{
  return (a < b) ? a : b;
}

inline int64x64_t Max (const int64x64_t &a, const int64x64_t &b)
{
  return (a > b) ? a : b;
}

} // namespace ns3

#endif /* INT64X64_H */