#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <limits>
#include <string>
#include <utility>
#include "util/util.h"
#include "util/flags.h"
#include "util/logging.h"
#include "util/pcre.h"
#include "util/strutil.h"

Include dependency graph for bloaty/third_party/re2/util/pcre.cc:

Classes
struct	pcre_extra

Namespaces
	re2

Macros
#define	DEFINE_INTEGER_PARSER(name)

#define	PCRE_ANCHORED 0

#define	PCRE_ERROR_MATCHLIMIT 2

#define	PCRE_ERROR_NOMATCH 1

#define	PCRE_ERROR_RECURSIONLIMIT 3

#define	PCRE_EXTRA_MATCH_LIMIT 0

#define	PCRE_EXTRA_MATCH_LIMIT_RECURSION 0

#define	PCRE_INFO_CAPTURECOUNT 0

#define	PCRE_NOTEMPTY 0

#define	PCREPORT(level) LOG(level)

Functions
	DEFINE_int32 (regexp_match_limit, 1000000, "default PCRE match limit (function calls)")

	DEFINE_int32 (regexp_stack_limit, 256<< 10, "default PCRE stack limit (bytes)")

	re2::DEFINE_INTEGER_PARSER (int)

	re2::DEFINE_INTEGER_PARSER (long)

	re2::DEFINE_INTEGER_PARSER (longlong)

	re2::DEFINE_INTEGER_PARSER (short)

	re2::DEFINE_INTEGER_PARSER (uint)

	re2::DEFINE_INTEGER_PARSER (ulong)

	re2::DEFINE_INTEGER_PARSER (ulonglong)

	re2::DEFINE_INTEGER_PARSER (ushort)

static bool	re2::parse_double_float (const char str, size_t n, bool isfloat, void dest)

pcre *	pcre_compile (const char , int, const char , int , const unsigned char *)

int	pcre_exec (const pcre , const pcre_extra , const char , int, int, int, int , int)

void	pcre_free (void *)

int	pcre_fullinfo (const pcre , const pcre_extra , int, void *)

static const char *	re2::TerminateNumber (char buf, const char str, size_t n)

Variables
static const std::string	re2::empty_string

static const int	re2::kMaxArgs = 16

static const int	re2::kMaxNumberLength = 32

static const int	re2::kPCREFrameSize = 700

static const int	re2::kVecSize = (1 + kMaxArgs) * 3

Macro Definition Documentation

◆ DEFINE_INTEGER_PARSER

#define DEFINE_INTEGER_PARSER ( name )

Value:

  bool PCRE::Arg::parse_##name(const char* str, size_t n, void* dest) {       \
    return parse_##name##_radix(str, n, dest, 10);                            \
  }                                                                           \
  bool PCRE::Arg::parse_##name##_hex(const char* str, size_t n, void* dest) { \
    return parse_##name##_radix(str, n, dest, 16);                            \
  }                                                                           \
  bool PCRE::Arg::parse_##name##_octal(const char* str, size_t n,             \
                                       void* dest) {                          \
    return parse_##name##_radix(str, n, dest, 8);                             \
  }                                                                           \
  bool PCRE::Arg::parse_##name##_cradix(const char* str, size_t n,            \
                                        void* dest) {                         \
    return parse_##name##_radix(str, n, dest, 0);                             \
  }