_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer4MiscEEEPT_PS1_:
  577|  4.89k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  4.89k|    static_assert(
  579|  4.89k|        InternalHelper<T>::is_arena_constructable::value,
  580|  4.89k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  4.89k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 4.89k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  4.89k|      return InternalHelper<T>::New();
  585|  4.89k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  4.89k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer4MiscEE3NewEv:
  491|  4.89k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  4.89k|      return new T(nullptr);
  493|  4.89k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer11ElementDeclEEEPT_PS1_:
  577|  5.73k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  5.73k|    static_assert(
  579|  5.73k|        InternalHelper<T>::is_arena_constructable::value,
  580|  5.73k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  5.73k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 5.73k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  5.73k|      return InternalHelper<T>::New();
  585|  5.73k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  5.73k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer11ElementDeclEE3NewEv:
  491|  5.73k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  5.73k|      return new T(nullptr);
  493|  5.73k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer10ExternalIdEEEPT_PS1_:
  577|  7.21k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  7.21k|    static_assert(
  579|  7.21k|        InternalHelper<T>::is_arena_constructable::value,
  580|  7.21k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  7.21k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 7.21k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  7.21k|      return InternalHelper<T>::New();
  585|  7.21k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  7.21k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer10ExternalIdEE3NewEv:
  491|  7.21k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  7.21k|      return new T(nullptr);
  493|  7.21k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer8AttValueEEEPT_PS1_:
  577|  2.69k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  2.69k|    static_assert(
  579|  2.69k|        InternalHelper<T>::is_arena_constructable::value,
  580|  2.69k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  2.69k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 2.69k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  2.69k|      return InternalHelper<T>::New();
  585|  2.69k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  2.69k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer8AttValueEE3NewEv:
  491|  2.69k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  2.69k|      return new T(nullptr);
  493|  2.69k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer11DefaultDeclEEEPT_PS1_:
  577|  4.58k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  4.58k|    static_assert(
  579|  4.58k|        InternalHelper<T>::is_arena_constructable::value,
  580|  4.58k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  4.58k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 4.58k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  4.58k|      return InternalHelper<T>::New();
  585|  4.58k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  4.58k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer11DefaultDeclEE3NewEv:
  491|  4.58k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  4.58k|      return new T(nullptr);
  493|  4.58k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer6AttDefEEEPT_PS1_:
  577|  19.2k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  19.2k|    static_assert(
  579|  19.2k|        InternalHelper<T>::is_arena_constructable::value,
  580|  19.2k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  19.2k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 19.2k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  19.2k|      return InternalHelper<T>::New();
  585|  19.2k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  19.2k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer6AttDefEE3NewEv:
  491|  19.2k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  19.2k|      return new T(nullptr);
  493|  19.2k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer11AttListDeclEEEPT_PS1_:
  577|  3.92k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  3.92k|    static_assert(
  579|  3.92k|        InternalHelper<T>::is_arena_constructable::value,
  580|  3.92k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  3.92k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 3.92k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  3.92k|      return InternalHelper<T>::New();
  585|  3.92k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  3.92k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer11AttListDeclEE3NewEv:
  491|  3.92k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  3.92k|      return new T(nullptr);
  493|  3.92k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer12NotationDeclEEEPT_PS1_:
  577|  5.63k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  5.63k|    static_assert(
  579|  5.63k|        InternalHelper<T>::is_arena_constructable::value,
  580|  5.63k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  5.63k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 5.63k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  5.63k|      return InternalHelper<T>::New();
  585|  5.63k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  5.63k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer12NotationDeclEE3NewEv:
  491|  5.63k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  5.63k|      return new T(nullptr);
  493|  5.63k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer11EntityValueEEEPT_PS1_:
  577|  4.36k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  4.36k|    static_assert(
  579|  4.36k|        InternalHelper<T>::is_arena_constructable::value,
  580|  4.36k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  4.36k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 4.36k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  4.36k|      return InternalHelper<T>::New();
  585|  4.36k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  4.36k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer11EntityValueEE3NewEv:
  491|  4.36k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  4.36k|      return new T(nullptr);
  493|  4.36k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer9NDataDeclEEEPT_PS1_:
  577|  1.71k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  1.71k|    static_assert(
  579|  1.71k|        InternalHelper<T>::is_arena_constructable::value,
  580|  1.71k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  1.71k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 1.71k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  1.71k|      return InternalHelper<T>::New();
  585|  1.71k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  1.71k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer9NDataDeclEE3NewEv:
  491|  1.71k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  1.71k|      return new T(nullptr);
  493|  1.71k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer9EntityDefEEEPT_PS1_:
  577|  7.68k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  7.68k|    static_assert(
  579|  7.68k|        InternalHelper<T>::is_arena_constructable::value,
  580|  7.68k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  7.68k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 7.68k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  7.68k|      return InternalHelper<T>::New();
  585|  7.68k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  7.68k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer9EntityDefEE3NewEv:
  491|  7.68k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  7.68k|      return new T(nullptr);
  493|  7.68k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer5PEDefEEEPT_PS1_:
  577|  3.42k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  3.42k|    static_assert(
  579|  3.42k|        InternalHelper<T>::is_arena_constructable::value,
  580|  3.42k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  3.42k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 3.42k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  3.42k|      return InternalHelper<T>::New();
  585|  3.42k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  3.42k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer5PEDefEE3NewEv:
  491|  3.42k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  3.42k|      return new T(nullptr);
  493|  3.42k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer10EntityDeclEEEPT_PS1_:
  577|  13.0k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  13.0k|    static_assert(
  579|  13.0k|        InternalHelper<T>::is_arena_constructable::value,
  580|  13.0k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  13.0k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 13.0k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  13.0k|      return InternalHelper<T>::New();
  585|  13.0k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  13.0k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer10EntityDeclEE3NewEv:
  491|  13.0k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  13.0k|      return new T(nullptr);
  493|  13.0k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer15ConditionalSectEEEPT_PS1_:
  577|  7.30k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  7.30k|    static_assert(
  579|  7.30k|        InternalHelper<T>::is_arena_constructable::value,
  580|  7.30k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  7.30k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 7.30k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  7.30k|      return InternalHelper<T>::New();
  585|  7.30k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  7.30k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer15ConditionalSectEE3NewEv:
  491|  7.30k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  7.30k|      return new T(nullptr);
  493|  7.30k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer16OneExtSubsetDeclEEEPT_PS1_:
  577|  34.5k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  34.5k|    static_assert(
  579|  34.5k|        InternalHelper<T>::is_arena_constructable::value,
  580|  34.5k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  34.5k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 34.5k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  34.5k|      return InternalHelper<T>::New();
  585|  34.5k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  34.5k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer16OneExtSubsetDeclEE3NewEv:
  491|  34.5k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  34.5k|      return new T(nullptr);
  493|  34.5k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer13ExtSubsetDeclEEEPT_PS1_:
  577|  8.80k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  8.80k|    static_assert(
  579|  8.80k|        InternalHelper<T>::is_arena_constructable::value,
  580|  8.80k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  8.80k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 8.80k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  8.80k|      return InternalHelper<T>::New();
  585|  8.80k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  8.80k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer13ExtSubsetDeclEE3NewEv:
  491|  8.80k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  8.80k|      return new T(nullptr);
  493|  8.80k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer10MarkupDeclEEEPT_PS1_:
  577|  42.0k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  42.0k|    static_assert(
  579|  42.0k|        InternalHelper<T>::is_arena_constructable::value,
  580|  42.0k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  42.0k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 42.0k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  42.0k|      return InternalHelper<T>::New();
  585|  42.0k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  42.0k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer10MarkupDeclEE3NewEv:
  491|  42.0k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  42.0k|      return new T(nullptr);
  493|  42.0k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer11DocTypeDeclEEEPT_PS1_:
  577|  7.75k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  7.75k|    static_assert(
  579|  7.75k|        InternalHelper<T>::is_arena_constructable::value,
  580|  7.75k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  7.75k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 7.75k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  7.75k|      return InternalHelper<T>::New();
  585|  7.75k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  7.75k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer11DocTypeDeclEE3NewEv:
  491|  7.75k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  7.75k|      return new T(nullptr);
  493|  7.75k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer6PrologEEEPT_PS1_:
  577|  8.20k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  8.20k|    static_assert(
  579|  8.20k|        InternalHelper<T>::is_arena_constructable::value,
  580|  8.20k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  8.20k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 8.20k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  8.20k|      return InternalHelper<T>::New();
  585|  8.20k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  8.20k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer6PrologEE3NewEv:
  491|  8.20k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  8.20k|      return new T(nullptr);
  493|  8.20k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer8KeyValueEEEPT_PS1_:
  577|  34.2k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  34.2k|    static_assert(
  579|  34.2k|        InternalHelper<T>::is_arena_constructable::value,
  580|  34.2k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  34.2k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 34.2k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  34.2k|      return InternalHelper<T>::New();
  585|  34.2k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  34.2k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer8KeyValueEE3NewEv:
  491|  34.2k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  34.2k|      return new T(nullptr);
  493|  34.2k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer21ProcessingInstructionEEEPT_PS1_:
  577|  1.51k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  1.51k|    static_assert(
  579|  1.51k|        InternalHelper<T>::is_arena_constructable::value,
  580|  1.51k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  1.51k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 1.51k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  1.51k|      return InternalHelper<T>::New();
  585|  1.51k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  1.51k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer21ProcessingInstructionEE3NewEv:
  491|  1.51k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  1.51k|      return new T(nullptr);
  493|  1.51k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer5CDataEEEPT_PS1_:
  577|  3.65k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  3.65k|    static_assert(
  579|  3.65k|        InternalHelper<T>::is_arena_constructable::value,
  580|  3.65k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  3.65k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 3.65k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  3.65k|      return InternalHelper<T>::New();
  585|  3.65k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  3.65k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer5CDataEE3NewEv:
  491|  3.65k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  3.65k|      return new T(nullptr);
  493|  3.65k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer7ContentEEEPT_PS1_:
  577|  21.2k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  21.2k|    static_assert(
  579|  21.2k|        InternalHelper<T>::is_arena_constructable::value,
  580|  21.2k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  21.2k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 21.2k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  21.2k|      return InternalHelper<T>::New();
  585|  21.2k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  21.2k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer7ContentEE3NewEv:
  491|  21.2k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  21.2k|      return new T(nullptr);
  493|  21.2k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer7ElementEEEPT_PS1_:
  577|   417k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|   417k|    static_assert(
  579|   417k|        InternalHelper<T>::is_arena_constructable::value,
  580|   417k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|   417k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 417k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|   417k|      return InternalHelper<T>::New();
  585|   417k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|   417k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer7ElementEE3NewEv:
  491|   417k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|   417k|      return new T(nullptr);
  493|   417k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer10VersionNumEEEPT_PS1_:
  577|    224|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|    224|    static_assert(
  579|    224|        InternalHelper<T>::is_arena_constructable::value,
  580|    224|        "CreateMessage can only construct types that are ArenaConstructable");
  581|    224|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 224, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|    224|      return InternalHelper<T>::New();
  585|    224|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|    224|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer10VersionNumEE3NewEv:
  491|    224|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|    224|      return new T(nullptr);
  493|    224|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer9EncodingsEEEPT_PS1_:
  577|  1.75k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  1.75k|    static_assert(
  579|  1.75k|        InternalHelper<T>::is_arena_constructable::value,
  580|  1.75k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  1.75k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 1.75k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  1.75k|      return InternalHelper<T>::New();
  585|  1.75k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  1.75k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer9EncodingsEE3NewEv:
  491|  1.75k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  1.75k|      return new T(nullptr);
  493|  1.75k|    }
_ZN6google8protobuf5Arena21CreateMessageInternalIN14xmlProtoFuzzer14XmlDeclarationEEEPT_PS1_:
  577|  2.11k|  PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) {
  578|  2.11k|    static_assert(
  579|  2.11k|        InternalHelper<T>::is_arena_constructable::value,
  580|  2.11k|        "CreateMessage can only construct types that are ArenaConstructable");
  581|  2.11k|    if (arena == NULL) {
  ------------------
  |  Branch (581:9): [True: 2.11k, False: 0]
  ------------------
  582|       |      // Generated arena constructor T(Arena*) is protected. Call via
  583|       |      // InternalHelper.
  584|  2.11k|      return InternalHelper<T>::New();
  585|  2.11k|    } else {
  586|      0|      return arena->DoCreateMessage<T>();
  587|      0|    }
  588|  2.11k|  }
_ZN6google8protobuf5Arena14InternalHelperIN14xmlProtoFuzzer14XmlDeclarationEE3NewEv:
  491|  2.11k|    static inline PROTOBUF_ALWAYS_INLINE T* New() {
  492|  2.11k|      return new T(nullptr);
  493|  2.11k|    }

_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  295|   976k|  PROTOBUF_NDEBUG_INLINE const std::string& Get() const {
  296|       |    // Unconditionally mask away the tag.
  297|   976k|    return *tagged_ptr_.Get();
  298|   976k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr3GetEv:
  189|   976k|  inline std::string* Get() const {
  190|   976k|    return reinterpret_cast<std::string*>(as_int() & ~kMask);
  191|   976k|  }
_ZNK6google8protobuf8internal15TaggedStringPtr6as_intEv:
  210|   976k|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZN6google8protobuf8internal14ArenaStringPtr11InitDefaultEv:
  391|   983k|inline void ArenaStringPtr::InitDefault() {
  392|   983k|  tagged_ptr_ = TaggedStringPtr(&fixed_address_empty_string);
  393|   983k|}
_ZN6google8protobuf8internal15TaggedStringPtrC2EPNS1_21ExplicitlyConstructedINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELm8EEE:
  133|   983k|      : ptr_(ptr) {}

_ZN6google8protobuf2io17CodedOutputStream12VarintSize32Ej:
 1728|  28.3k|inline size_t CodedOutputStream::VarintSize32(uint32_t value) {
 1729|       |  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
 1730|       |  // Use an explicit multiplication to implement the divide of
 1731|       |  // a number in the 1..31 range.
 1732|       |  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
 1733|       |  // undefined.
 1734|  28.3k|  uint32_t log2value = Bits::Log2FloorNonZero(value | 0x1);
 1735|  28.3k|  return static_cast<size_t>((log2value * 9 + 73) / 64);
 1736|  28.3k|}
_ZN6google8protobuf2io17CodedOutputStream24VarintSize32SignExtendedEi:
 1760|  14.8k|inline size_t CodedOutputStream::VarintSize32SignExtended(int32_t value) {
 1761|  14.8k|  return VarintSize64(static_cast<uint64_t>(int64_t{value}));
 1762|  14.8k|}
_ZN6google8protobuf2io17CodedOutputStream12VarintSize64Em:
 1744|  14.8k|inline size_t CodedOutputStream::VarintSize64(uint64_t value) {
 1745|       |  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
 1746|       |  // Use an explicit multiplication to implement the divide of
 1747|       |  // a number in the 1..63 range.
 1748|       |  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
 1749|       |  // undefined.
 1750|  14.8k|  uint32_t log2value = Bits::Log2FloorNonZero64(value | 0x1);
 1751|  14.8k|  return static_cast<size_t>((log2value * 9 + 73) / 64);
 1752|  14.8k|}

_ZN6google8protobuf7MessageC2EPNS0_5ArenaEb:
  394|   683k|      : MessageLite(arena, is_message_owned) {}

_ZNK6google8protobuf11MessageLite21GetArenaForAllocationEv:
  440|   108k|  Arena* GetArenaForAllocation() const { return _internal_metadata_.arena(); }
_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaEb:
  429|   683k|      : _internal_metadata_(arena, is_message_owned) {}
_ZN6google8protobuf11MessageLiteD2Ev:
  171|   683k|  virtual ~MessageLite() = default;
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer21ProcessingInstructionEEEPT_PNS0_5ArenaE:
  424|  1.51k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  1.51k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  1.51k|  }
_ZN6google8protobuf8internal11FromIntSizeEi:
  114|  2.82k|inline size_t FromIntSize(int size) {
  115|       |  // Convert to unsigned before widening so sign extension is not necessary.
  116|  2.82k|  return static_cast<unsigned int>(size);
  117|  2.82k|}
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer11DefaultDeclEEEPT_PNS0_5ArenaE:
  424|  4.58k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  4.58k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  4.58k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer8AttValueEEEPT_PNS0_5ArenaE:
  424|  2.69k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  2.69k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  2.69k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer10ExternalIdEEEPT_PNS0_5ArenaE:
  424|  7.21k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  7.21k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  7.21k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer11EntityValueEEEPT_PNS0_5ArenaE:
  424|  4.36k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  4.36k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  4.36k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer9NDataDeclEEEPT_PNS0_5ArenaE:
  424|  1.71k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  1.71k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  1.71k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer9EntityDefEEEPT_PNS0_5ArenaE:
  424|  7.68k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  7.68k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  7.68k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer5PEDefEEEPT_PNS0_5ArenaE:
  424|  3.42k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  3.42k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  3.42k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer13ExtSubsetDeclEEEPT_PNS0_5ArenaE:
  424|  8.80k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  8.80k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  8.80k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer10MarkupDeclEEEPT_PNS0_5ArenaE:
  424|  42.0k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  42.0k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  42.0k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer15ConditionalSectEEEPT_PNS0_5ArenaE:
  424|  7.30k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  7.30k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  7.30k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer11ElementDeclEEEPT_PNS0_5ArenaE:
  424|  5.73k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  5.73k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  5.73k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer11AttListDeclEEEPT_PNS0_5ArenaE:
  424|  3.92k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  3.92k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  3.92k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer12NotationDeclEEEPT_PNS0_5ArenaE:
  424|  5.63k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  5.63k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  5.63k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer4MiscEEEPT_PNS0_5ArenaE:
  424|  4.89k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  4.89k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  4.89k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer10EntityDeclEEEPT_PNS0_5ArenaE:
  424|  13.0k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  13.0k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  13.0k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer14XmlDeclarationEEEPT_PNS0_5ArenaE:
  424|  2.11k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  2.11k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  2.11k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer11DocTypeDeclEEEPT_PNS0_5ArenaE:
  424|  7.75k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  7.75k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  7.75k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer7ElementEEEPT_PNS0_5ArenaE:
  424|   417k|  static T* CreateMaybeMessage(Arena* arena) {
  425|   417k|    return Arena::CreateMaybeMessage<T>(arena);
  426|   417k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer5CDataEEEPT_PNS0_5ArenaE:
  424|  3.65k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  3.65k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  3.65k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer7ContentEEEPT_PNS0_5ArenaE:
  424|  21.2k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  21.2k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  21.2k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer10VersionNumEEEPT_PNS0_5ArenaE:
  424|    224|  static T* CreateMaybeMessage(Arena* arena) {
  425|    224|    return Arena::CreateMaybeMessage<T>(arena);
  426|    224|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer9EncodingsEEEPT_PNS0_5ArenaE:
  424|  1.75k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  1.75k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  1.75k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer6PrologEEEPT_PNS0_5ArenaE:
  424|  8.20k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  8.20k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  8.20k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer6AttDefEEEPT_PNS0_5ArenaE:
  424|  19.2k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  19.2k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  19.2k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer16OneExtSubsetDeclEEEPT_PNS0_5ArenaE:
  424|  34.5k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  34.5k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  34.5k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN14xmlProtoFuzzer8KeyValueEEEPT_PNS0_5ArenaE:
  424|  34.2k|  static T* CreateMaybeMessage(Arena* arena) {
  425|  34.2k|    return Arena::CreateMaybeMessage<T>(arena);
  426|  34.2k|  }

_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
  124|   108k|  PROTOBUF_NDEBUG_INLINE Arena* arena() const {
  125|   108k|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  490|   108k|# define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (490:36): [True: 0, False: 108k]
  |  |  |  Branch (490:54): [Folded - Ignored]
  |  |  |  Branch (490:63): [True: 0, False: 108k]
  |  |  ------------------
  ------------------
  126|      0|      return PtrValue<ContainerBase>()->arena;
  127|   108k|    } else {
  128|   108k|      return PtrValue<Arena>();
  129|   108k|    }
  130|   108k|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  209|   792k|  U* PtrValue() const {
  210|   792k|    return reinterpret_cast<U*>(ptr_ & kPtrValueMask);
  211|   792k|  }
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaEb:
   66|   683k|  explicit InternalMetadata(Arena* arena, bool is_message_owned = false) {
   67|   683k|    SetArena(arena, is_message_owned);
   68|   683k|  }
_ZN6google8protobuf8internal16InternalMetadata8SetArenaEPNS0_5ArenaEb:
   70|   683k|  void SetArena(Arena* arena, bool is_message_owned) {
   71|   683k|    ptr_ = is_message_owned
  ------------------
  |  Branch (71:12): [True: 0, False: 683k]
  ------------------
   72|   683k|               ? reinterpret_cast<intptr_t>(arena) | kMessageOwnedArenaTagMask
   73|   683k|               : reinterpret_cast<intptr_t>(arena);
   74|   683k|    GOOGLE_DCHECK(!is_message_owned || arena != nullptr);
  ------------------
  |  |  179|   683k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (149:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (149:5): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
   75|   683k|  }
_ZN6google8protobuf8internal16InternalMetadataD2Ev:
   81|   683k|  ~InternalMetadata() {
   82|   683k|#if defined(NDEBUG) || defined(_MSC_VER)
   83|   683k|    if (HasMessageOwnedArenaTag()) {
  ------------------
  |  Branch (83:9): [True: 0, False: 683k]
  ------------------
   84|      0|      delete reinterpret_cast<Arena*>(ptr_ - kMessageOwnedArenaTagMask);
   85|      0|    }
   86|       |#else
   87|       |    CheckedDestruct();
   88|       |#endif
   89|   683k|  }
_ZNK6google8protobuf8internal16InternalMetadata23HasMessageOwnedArenaTagEv:
  204|   683k|  PROTOBUF_ALWAYS_INLINE bool HasMessageOwnedArenaTag() const {
  205|   683k|    return ptr_ & kMessageOwnedArenaTagMask;
  206|   683k|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
  132|   817k|  PROTOBUF_NDEBUG_INLINE bool have_unknown_fields() const {
  133|   817k|    return HasUnknownFieldsTag();
  134|   817k|  }
_ZNK6google8protobuf8internal16InternalMetadata19HasUnknownFieldsTagEv:
  201|   817k|  PROTOBUF_ALWAYS_INLINE bool HasUnknownFieldsTag() const {
  202|   817k|    return ptr_ & kUnknownFieldsTagMask;
  203|   817k|  }
_ZN6google8protobuf8internal16InternalMetadata17DeleteReturnArenaINS0_15UnknownFieldSetEEEPNS0_5ArenaEv:
  107|   683k|  Arena* DeleteReturnArena() {
  108|   683k|    if (have_unknown_fields()) {
  ------------------
  |  Branch (108:9): [True: 0, False: 683k]
  ------------------
  109|      0|      return DeleteOutOfLineHelper<T>();
  110|   683k|    } else {
  111|   683k|      return PtrValue<Arena>();
  112|   683k|    }
  113|   683k|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINS0_15UnknownFieldSetEEEvv:
  184|  24.6k|  PROTOBUF_NDEBUG_INLINE void Clear() {
  185|  24.6k|    if (have_unknown_fields()) {
  ------------------
  |  Branch (185:9): [True: 0, False: 24.6k]
  ------------------
  186|      0|      DoClear<T>();
  187|      0|    }
  188|  24.6k|  }

_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS0_5ArenaE:
 1169|  20.1k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
  171|   476k|      : arena_(arena), current_size_(0), total_size_(0), rep_(nullptr) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEPNT_4TypeEPv:
  649|  4.61k|  static inline typename TypeHandler::Type* cast(void* element) {
  650|  4.61k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  651|  4.61k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer6AttDefEEC2EPNS0_5ArenaE:
 1169|  3.92k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer6AttDefEED2Ev:
 1185|  3.92k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1186|       |#ifdef __cpp_if_constexpr
 1187|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1188|       |#else
 1189|  3.92k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1189:7): [Folded - Ignored]
  ------------------
 1190|  3.92k|#endif
 1191|  3.92k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1191:9): [True: 2.92k, False: 1.00k]
  ------------------
 1192|  3.92k|  } else {
 1193|      0|    Destroy<TypeHandler>();
 1194|      0|  }
 1195|  3.92k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase12NeedsDestroyEv:
  260|   456k|  bool NeedsDestroy() const { return rep_ != nullptr && arena_ == nullptr; }
  ------------------
  |  Branch (260:38): [True: 39.7k, False: 416k]
  |  Branch (260:57): [True: 39.7k, False: 0]
  ------------------
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  176|   456k|  ~RepeatedPtrFieldBase() {
  177|       |#ifndef NDEBUG
  178|       |    // Try to trigger segfault / asan failure in non-opt builds. If arena_
  179|       |    // lifetime has ended before the destructor.
  180|       |    if (arena_) (void)arena_->SpaceAllocated();
  181|       |#endif
  182|   456k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer6AttDefEE4sizeEv:
 1247|  3.81k|inline int RepeatedPtrField<Element>::size() const {
 1248|  3.81k|  return RepeatedPtrFieldBase::size();
 1249|  3.81k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
  185|   468k|  int size() const { return current_size_; }
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer16OneExtSubsetDeclEEC2EPNS0_5ArenaE:
 1169|  8.80k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer16OneExtSubsetDeclEED2Ev:
 1185|  8.80k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1186|       |#ifdef __cpp_if_constexpr
 1187|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1188|       |#else
 1189|  8.80k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1189:7): [Folded - Ignored]
  ------------------
 1190|  8.80k|#endif
 1191|  8.80k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1191:9): [True: 7.42k, False: 1.38k]
  ------------------
 1192|  8.80k|  } else {
 1193|      0|    Destroy<TypeHandler>();
 1194|      0|  }
 1195|  8.80k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer16OneExtSubsetDeclEE4sizeEv:
 1247|  11.0k|inline int RepeatedPtrField<Element>::size() const {
 1248|  11.0k|  return RepeatedPtrFieldBase::size();
 1249|  11.0k|}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer10MarkupDeclEEC2EPNS0_5ArenaE:
 1169|  7.75k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer10MarkupDeclEED2Ev:
 1185|  7.75k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1186|       |#ifdef __cpp_if_constexpr
 1187|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1188|       |#else
 1189|  7.75k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1189:7): [Folded - Ignored]
  ------------------
 1190|  7.75k|#endif
 1191|  7.75k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1191:9): [True: 7.20k, False: 553]
  ------------------
 1192|  7.75k|  } else {
 1193|      0|    Destroy<TypeHandler>();
 1194|      0|  }
 1195|  7.75k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer10MarkupDeclEE4sizeEv:
 1247|  8.51k|inline int RepeatedPtrField<Element>::size() const {
 1248|  8.51k|  return RepeatedPtrFieldBase::size();
 1249|  8.51k|}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer4MiscEEC2EPNS0_5ArenaE:
 1169|  8.20k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer4MiscEED2Ev:
 1185|  8.20k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1186|       |#ifdef __cpp_if_constexpr
 1187|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1188|       |#else
 1189|  8.20k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1189:7): [Folded - Ignored]
  ------------------
 1190|  8.20k|#endif
 1191|  8.20k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1191:9): [True: 728, False: 7.47k]
  ------------------
 1192|  8.20k|  } else {
 1193|      0|    Destroy<TypeHandler>();
 1194|      0|  }
 1195|  8.20k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer4MiscEE4sizeEv:
 1247|  8.51k|inline int RepeatedPtrField<Element>::size() const {
 1248|  8.51k|  return RepeatedPtrFieldBase::size();
 1249|  8.51k|}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEEC2EPNS0_5ArenaE:
 1169|   418k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEED2Ev:
 1185|   418k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1186|       |#ifdef __cpp_if_constexpr
 1187|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1188|       |#else
 1189|   418k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1189:7): [Folded - Ignored]
  ------------------
 1190|   418k|#endif
 1191|   418k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1191:9): [True: 19.2k, False: 399k]
  ------------------
 1192|   418k|  } else {
 1193|      0|    Destroy<TypeHandler>();
 1194|      0|  }
 1195|   418k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEE11TypeHandlerEEEPNT_4TypeEPv:
  649|  1.29k|  static inline typename TypeHandler::Type* cast(void* element) {
  650|  1.29k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  651|  1.29k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEE4sizeEv:
 1247|   412k|inline int RepeatedPtrField<Element>::size() const {
 1248|   412k|  return RepeatedPtrFieldBase::size();
 1249|   412k|}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEEC2EPNS0_5ArenaE:
 1169|  8.78k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEED2Ev:
 1185|  8.78k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 1186|       |#ifdef __cpp_if_constexpr
 1187|       |  if constexpr (std::is_base_of<MessageLite, Element>::value) {
 1188|       |#else
 1189|  8.78k|  if (std::is_base_of<MessageLite, Element>::value) {
  ------------------
  |  Branch (1189:7): [Folded - Ignored]
  ------------------
 1190|  8.78k|#endif
 1191|  8.78k|    if (NeedsDestroy()) DestroyProtos();
  ------------------
  |  Branch (1191:9): [True: 2.14k, False: 6.63k]
  ------------------
 1192|  8.78k|  } else {
 1193|      0|    Destroy<TypeHandler>();
 1194|      0|  }
 1195|  8.78k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEE11TypeHandlerEEEPNT_4TypeEPv:
  649|  5.55k|  static inline typename TypeHandler::Type* cast(void* element) {
  650|  5.55k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  651|  5.55k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEE4sizeEv:
 1247|  8.51k|inline int RepeatedPtrField<Element>::size() const {
 1248|  8.51k|  return RepeatedPtrFieldBase::size();
 1249|  8.51k|}
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4sizeEv:
 1247|  16.3k|inline int RepeatedPtrField<Element>::size() const {
 1248|  16.3k|  return RepeatedPtrFieldBase::size();
 1249|  16.3k|}
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3GetEi:
 1252|  4.61k|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 1253|  4.61k|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 1254|  4.61k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEERKNT_4TypeEi:
  269|  4.61k|  const typename TypeHandler::Type& Get(int index) const {
  270|  4.61k|    GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  186|  4.61k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  179|  4.61k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  271|  4.61k|    GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  183|  4.61k|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  179|  4.61k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  272|  4.61k|    return *cast<TypeHandler>(rep_->elements[index]);
  273|  4.61k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEE5ClearEv:
 1402|  5.55k|inline void RepeatedPtrField<Element>::Clear() {
 1403|  5.55k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1404|  5.55k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEE11TypeHandlerEEEvv:
  282|  5.55k|  void Clear() {
  283|  5.55k|    const int n = current_size_;
  284|  5.55k|    GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  186|  5.55k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  179|  5.55k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  285|  5.55k|    if (n > 0) {
  ------------------
  |  Branch (285:9): [True: 834, False: 4.71k]
  ------------------
  286|    834|      void* const* elements = rep_->elements;
  287|    834|      int i = 0;
  288|  1.29k|      do {
  289|  1.29k|        TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
  290|  1.29k|      } while (i < n);
  ------------------
  |  Branch (290:16): [True: 463, False: 834]
  ------------------
  291|    834|      current_size_ = 0;
  292|    834|    }
  293|  5.55k|  }
_ZN6google8protobuf8internal18GenericTypeHandlerIN14xmlProtoFuzzer8KeyValueEE5ClearEPS4_:
  768|  1.29k|  static inline void Clear(GenericType* value) { value->Clear(); }
_ZN6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEE5ClearEv:
 1402|  17.8k|inline void RepeatedPtrField<Element>::Clear() {
 1403|  17.8k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 1404|  17.8k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEE11TypeHandlerEEEvv:
  282|  17.8k|  void Clear() {
  283|  17.8k|    const int n = current_size_;
  284|  17.8k|    GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  186|  17.8k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  179|  17.8k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  285|  17.8k|    if (n > 0) {
  ------------------
  |  Branch (285:9): [True: 82, False: 17.7k]
  ------------------
  286|     82|      void* const* elements = rep_->elements;
  287|     82|      int i = 0;
  288|  5.55k|      do {
  289|  5.55k|        TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
  290|  5.55k|      } while (i < n);
  ------------------
  |  Branch (290:16): [True: 5.47k, False: 82]
  ------------------
  291|     82|      current_size_ = 0;
  292|     82|    }
  293|  17.8k|  }
_ZN6google8protobuf8internal18GenericTypeHandlerIN14xmlProtoFuzzer7ElementEE5ClearEPS4_:
  768|  5.55k|  static inline void Clear(GenericType* value) { value->Clear(); }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer6AttDefEE5beginEv:
 1758|  3.81k|RepeatedPtrField<Element>::begin() const {
 1759|  3.81k|  return iterator(raw_data());
 1760|  3.81k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
  347|   924k|  void* const* raw_data() const { return rep_ ? rep_->elements : nullptr; }
  ------------------
  |  Branch (347:42): [True: 86.5k, False: 837k]
  ------------------
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN14xmlProtoFuzzer6AttDefEEC2EPKPv:
 1556|  7.63k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer6AttDefEEC2IS4_LPv0EEERKNS2_IT_EE:
 1564|  7.63k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer6AttDefEE3endEv:
 1773|  3.81k|RepeatedPtrField<Element>::end() const {
 1774|  3.81k|  return iterator(raw_data() + size());
 1775|  3.81k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN14xmlProtoFuzzer6AttDefEEES8_:
 1586|  22.6k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|  22.6k|    return x.it_ != y.it_;
 1588|  22.6k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer6AttDefEEppEv:
 1571|  18.8k|  iterator& operator++() {
 1572|  18.8k|    ++it_;
 1573|  18.8k|    return *this;
 1574|  18.8k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer6AttDefEEdeEv:
 1567|  18.8k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer16OneExtSubsetDeclEE5beginEv:
 1758|  11.0k|RepeatedPtrField<Element>::begin() const {
 1759|  11.0k|  return iterator(raw_data());
 1760|  11.0k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN14xmlProtoFuzzer16OneExtSubsetDeclEEC2EPKPv:
 1556|  22.0k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer16OneExtSubsetDeclEEC2IS4_LPv0EEERKNS2_IT_EE:
 1564|  22.0k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer16OneExtSubsetDeclEE3endEv:
 1773|  11.0k|RepeatedPtrField<Element>::end() const {
 1774|  11.0k|  return iterator(raw_data() + size());
 1775|  11.0k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN14xmlProtoFuzzer16OneExtSubsetDeclEEES8_:
 1586|  44.8k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|  44.8k|    return x.it_ != y.it_;
 1588|  44.8k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer16OneExtSubsetDeclEEppEv:
 1571|  33.8k|  iterator& operator++() {
 1572|  33.8k|    ++it_;
 1573|  33.8k|    return *this;
 1574|  33.8k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer16OneExtSubsetDeclEEdeEv:
 1567|  33.8k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer10MarkupDeclEE5beginEv:
 1758|  8.51k|RepeatedPtrField<Element>::begin() const {
 1759|  8.51k|  return iterator(raw_data());
 1760|  8.51k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN14xmlProtoFuzzer10MarkupDeclEEC2EPKPv:
 1556|  17.0k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer10MarkupDeclEEC2IS4_LPv0EEERKNS2_IT_EE:
 1564|  17.0k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer10MarkupDeclEE3endEv:
 1773|  8.51k|RepeatedPtrField<Element>::end() const {
 1774|  8.51k|  return iterator(raw_data() + size());
 1775|  8.51k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN14xmlProtoFuzzer10MarkupDeclEEES8_:
 1586|  29.7k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|  29.7k|    return x.it_ != y.it_;
 1588|  29.7k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer10MarkupDeclEEppEv:
 1571|  21.2k|  iterator& operator++() {
 1572|  21.2k|    ++it_;
 1573|  21.2k|    return *this;
 1574|  21.2k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer10MarkupDeclEEdeEv:
 1567|  21.2k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer4MiscEE5beginEv:
 1758|  8.51k|RepeatedPtrField<Element>::begin() const {
 1759|  8.51k|  return iterator(raw_data());
 1760|  8.51k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN14xmlProtoFuzzer4MiscEEC2EPKPv:
 1556|  17.0k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer4MiscEEC2IS4_LPv0EEERKNS2_IT_EE:
 1564|  17.0k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer4MiscEE3endEv:
 1773|  8.51k|RepeatedPtrField<Element>::end() const {
 1774|  8.51k|  return iterator(raw_data() + size());
 1775|  8.51k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN14xmlProtoFuzzer4MiscEEES8_:
 1586|  11.2k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|  11.2k|    return x.it_ != y.it_;
 1588|  11.2k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer4MiscEEppEv:
 1571|  2.70k|  iterator& operator++() {
 1572|  2.70k|    ++it_;
 1573|  2.70k|    return *this;
 1574|  2.70k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer4MiscEEdeEv:
 1567|  2.70k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEE5beginEv:
 1758|   412k|RepeatedPtrField<Element>::begin() const {
 1759|   412k|  return iterator(raw_data());
 1760|   412k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN14xmlProtoFuzzer8KeyValueEEC2EPKPv:
 1556|   824k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer8KeyValueEEC2IS4_LPv0EEERKNS2_IT_EE:
 1564|   824k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer8KeyValueEE3endEv:
 1773|   412k|RepeatedPtrField<Element>::end() const {
 1774|   412k|  return iterator(raw_data() + size());
 1775|   412k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN14xmlProtoFuzzer8KeyValueEEES8_:
 1586|   443k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|   443k|    return x.it_ != y.it_;
 1588|   443k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer8KeyValueEEppEv:
 1571|  31.7k|  iterator& operator++() {
 1572|  31.7k|    ++it_;
 1573|  31.7k|    return *this;
 1574|  31.7k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer8KeyValueEEdeEv:
 1567|  31.7k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEE5beginEv:
 1758|  8.51k|RepeatedPtrField<Element>::begin() const {
 1759|  8.51k|  return iterator(raw_data());
 1760|  8.51k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN14xmlProtoFuzzer7ElementEEC2EPKPv:
 1556|  17.0k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer7ElementEEC2IS4_LPv0EEERKNS2_IT_EE:
 1564|  17.0k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN14xmlProtoFuzzer7ElementEE3endEv:
 1773|  8.51k|RepeatedPtrField<Element>::end() const {
 1774|  8.51k|  return iterator(raw_data() + size());
 1775|  8.51k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKN14xmlProtoFuzzer7ElementEEES8_:
 1586|   412k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|   412k|    return x.it_ != y.it_;
 1588|   412k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer7ElementEEppEv:
 1571|   404k|  iterator& operator++() {
 1572|   404k|    ++it_;
 1573|   404k|    return *this;
 1574|   404k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN14xmlProtoFuzzer7ElementEEdeEv:
 1567|   404k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5beginEv:
 1758|  9.64k|RepeatedPtrField<Element>::begin() const {
 1759|  9.64k|  return iterator(raw_data());
 1760|  9.64k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2EPKPv:
 1556|  19.2k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2IS9_LPv0EEERKNS2_IT_EE:
 1564|  19.2k|      : it_(other.it_) {}
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3endEv:
 1773|  9.64k|RepeatedPtrField<Element>::end() const {
 1774|  9.64k|  return iterator(raw_data() + size());
 1775|  9.64k|}
_ZN6google8protobuf8internalneERKNS1_19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEESD_:
 1586|  28.7k|  friend bool operator!=(const iterator& x, const iterator& y) {
 1587|  28.7k|    return x.it_ != y.it_;
 1588|  28.7k|  }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEppEv:
 1571|  19.0k|  iterator& operator++() {
 1572|  19.0k|    ++it_;
 1573|  19.0k|    return *this;
 1574|  19.0k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEdeEv:
 1567|  19.0k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }

_ZN6google8protobuf4Bits16Log2FloorNonZeroEj:
  290|  28.3k|  static uint32_t Log2FloorNonZero(uint32_t n) {
  291|  28.3k|#if defined(__GNUC__)
  292|  28.3k|  return 31 ^ static_cast<uint32_t>(__builtin_clz(n));
  293|       |#elif defined(_MSC_VER)
  294|       |  unsigned long where;
  295|       |  _BitScanReverse(&where, n);
  296|       |  return where;
  297|       |#else
  298|       |  return Log2FloorNonZero_Portable(n);
  299|       |#endif
  300|  28.3k|  }
_ZN6google8protobuf4Bits18Log2FloorNonZero64Em:
  302|  14.8k|  static uint32_t Log2FloorNonZero64(uint64_t n) {
  303|       |    // Older versions of clang run into an instruction-selection failure when
  304|       |    // it encounters __builtin_clzll:
  305|       |    // https://bugs.chromium.org/p/nativeclient/issues/detail?id=4395
  306|       |    // This includes arm-nacl-clang and clang in older Android NDK versions.
  307|       |    // To work around this, when we build with those we use the portable
  308|       |    // implementation instead.
  309|  14.8k|#if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_USE_PORTABLE_LOG2)
  310|  14.8k|  return 63 ^ static_cast<uint32_t>(__builtin_clzll(n));
  311|       |#elif defined(_MSC_VER) && defined(_M_X64)
  312|       |  unsigned long where;
  313|       |  _BitScanReverse64(&where, n);
  314|       |  return where;
  315|       |#else
  316|       |  return Log2FloorNonZero64_Portable(n);
  317|       |#endif
  318|  14.8k|  }

_ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1782|  22.7k|inline size_t WireFormatLite::StringSize(const std::string& value) {
 1783|  22.7k|  return LengthDelimitedSize(value.size());
 1784|  22.7k|}
_ZN6google8protobuf8internal14WireFormatLite19LengthDelimitedSizeEm:
 1813|  28.3k|inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
 1814|       |  // The static_cast here prevents an error in certain compiler configurations
 1815|       |  // but is not technically correct--if length is too large to fit in a uint32_t
 1816|       |  // then it will be silently truncated. We will need to fix this if we ever
 1817|       |  // decide to start supporting serialized messages greater than 2 GiB in size.
 1818|  28.3k|  return length +
 1819|  28.3k|         io::CodedOutputStream::VarintSize32(static_cast<uint32_t>(length));
 1820|  28.3k|}
_ZN6google8protobuf8internal14WireFormatLite8EnumSizeEi:
 1756|  14.8k|inline size_t WireFormatLite::EnumSize(int value) {
 1757|  14.8k|  return io::CodedOutputStream::VarintSize32SignExtended(value);
 1758|  14.8k|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN14xmlProtoFuzzer10ExternalIdEEEmRKT_:
 1795|  4.11k|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1796|  4.11k|  return LengthDelimitedSize(value.ByteSizeLong());
 1797|  4.11k|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN14xmlProtoFuzzer9NDataDeclEEEmRKT_:
 1795|  1.44k|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1796|  1.44k|  return LengthDelimitedSize(value.ByteSizeLong());
 1797|  1.44k|}

_Z35descriptor_table_xml_2eproto_getterv:
  974|      1|PROTOBUF_ATTRIBUTE_WEAK const ::_pbi::DescriptorTable* descriptor_table_xml_2eproto_getter() {
  975|      1|  return &descriptor_table_xml_2eproto;
  976|      1|}
_ZN14xmlProtoFuzzer31ElementDecl_ContentSpec_IsValidEi:
  985|  5.70k|bool ElementDecl_ContentSpec_IsValid(int value) {
  986|  5.70k|  switch (value) {
  987|  3.43k|    case 0:
  ------------------
  |  Branch (987:5): [True: 3.43k, False: 2.26k]
  ------------------
  988|  3.76k|    case 1:
  ------------------
  |  Branch (988:5): [True: 329, False: 5.37k]
  ------------------
  989|  3.87k|    case 2:
  ------------------
  |  Branch (989:5): [True: 105, False: 5.59k]
  ------------------
  990|  4.98k|    case 3:
  ------------------
  |  Branch (990:5): [True: 1.11k, False: 4.58k]
  ------------------
  991|  5.66k|    case 4:
  ------------------
  |  Branch (991:5): [True: 683, False: 5.01k]
  ------------------
  992|  5.66k|      return true;
  993|     34|    default:
  ------------------
  |  Branch (993:5): [True: 34, False: 5.66k]
  ------------------
  994|     34|      return false;
  995|  5.70k|  }
  996|  5.70k|}
_ZN14xmlProtoFuzzer23ExternalId_Type_IsValidEi:
 1045|  14.5k|bool ExternalId_Type_IsValid(int value) {
 1046|  14.5k|  switch (value) {
 1047|  11.4k|    case 0:
  ------------------
  |  Branch (1047:5): [True: 11.4k, False: 3.05k]
  ------------------
 1048|  12.6k|    case 1:
  ------------------
  |  Branch (1048:5): [True: 1.13k, False: 13.3k]
  ------------------
 1049|  13.3k|    case 2:
  ------------------
  |  Branch (1049:5): [True: 749, False: 13.7k]
  ------------------
 1050|  13.3k|      return true;
 1051|  1.16k|    default:
  ------------------
  |  Branch (1051:5): [True: 1.16k, False: 13.3k]
  ------------------
 1052|  1.16k|      return false;
 1053|  14.5k|  }
 1054|  14.5k|}
_ZN14xmlProtoFuzzer21AttValue_Type_IsValidEi:
 1068|  3.16k|bool AttValue_Type_IsValid(int value) {
 1069|  3.16k|  switch (value) {
 1070|  1.43k|    case 0:
  ------------------
  |  Branch (1070:5): [True: 1.43k, False: 1.73k]
  ------------------
 1071|  2.48k|    case 1:
  ------------------
  |  Branch (1071:5): [True: 1.05k, False: 2.11k]
  ------------------
 1072|  2.83k|    case 2:
  ------------------
  |  Branch (1072:5): [True: 349, False: 2.82k]
  ------------------
 1073|  2.83k|      return true;
 1074|    331|    default:
  ------------------
  |  Branch (1074:5): [True: 331, False: 2.83k]
  ------------------
 1075|    331|      return false;
 1076|  3.16k|  }
 1077|  3.16k|}
_ZN14xmlProtoFuzzer24DefaultDecl_Type_IsValidEi:
 1091|  18.7k|bool DefaultDecl_Type_IsValid(int value) {
 1092|  18.7k|  switch (value) {
 1093|  14.6k|    case 0:
  ------------------
  |  Branch (1093:5): [True: 14.6k, False: 4.09k]
  ------------------
 1094|  15.1k|    case 1:
  ------------------
  |  Branch (1094:5): [True: 433, False: 18.3k]
  ------------------
 1095|  18.2k|    case 2:
  ------------------
  |  Branch (1095:5): [True: 3.16k, False: 15.6k]
  ------------------
 1096|  18.5k|    case 3:
  ------------------
  |  Branch (1096:5): [True: 280, False: 18.5k]
  ------------------
 1097|  18.5k|      return true;
 1098|    213|    default:
  ------------------
  |  Branch (1098:5): [True: 213, False: 18.5k]
  ------------------
 1099|    213|      return false;
 1100|  18.7k|  }
 1101|  18.7k|}
_ZN14xmlProtoFuzzer19AttDef_Type_IsValidEi:
 1116|  18.8k|bool AttDef_Type_IsValid(int value) {
 1117|  18.8k|  switch (value) {
 1118|  12.8k|    case 0:
  ------------------
  |  Branch (1118:5): [True: 12.8k, False: 5.93k]
  ------------------
 1119|  15.5k|    case 1:
  ------------------
  |  Branch (1119:5): [True: 2.69k, False: 16.1k]
  ------------------
 1120|  16.2k|    case 2:
  ------------------
  |  Branch (1120:5): [True: 692, False: 18.1k]
  ------------------
 1121|  17.1k|    case 3:
  ------------------
  |  Branch (1121:5): [True: 894, False: 17.9k]
  ------------------
 1122|  17.4k|    case 4:
  ------------------
  |  Branch (1122:5): [True: 333, False: 18.4k]
  ------------------
 1123|  17.8k|    case 5:
  ------------------
  |  Branch (1123:5): [True: 361, False: 18.4k]
  ------------------
 1124|  18.3k|    case 6:
  ------------------
  |  Branch (1124:5): [True: 454, False: 18.3k]
  ------------------
 1125|  18.6k|    case 7:
  ------------------
  |  Branch (1125:5): [True: 324, False: 18.5k]
  ------------------
 1126|  18.7k|    case 8:
  ------------------
  |  Branch (1126:5): [True: 151, False: 18.6k]
  ------------------
 1127|  18.7k|      return true;
 1128|     38|    default:
  ------------------
  |  Branch (1128:5): [True: 38, False: 18.7k]
  ------------------
 1129|     38|      return false;
 1130|  18.8k|  }
 1131|  18.8k|}
_ZN14xmlProtoFuzzer24EntityValue_Type_IsValidEi:
 1151|  4.19k|bool EntityValue_Type_IsValid(int value) {
 1152|  4.19k|  switch (value) {
 1153|  1.83k|    case 0:
  ------------------
  |  Branch (1153:5): [True: 1.83k, False: 2.35k]
  ------------------
 1154|  3.60k|    case 1:
  ------------------
  |  Branch (1154:5): [True: 1.77k, False: 2.42k]
  ------------------
 1155|  3.82k|    case 2:
  ------------------
  |  Branch (1155:5): [True: 221, False: 3.97k]
  ------------------
 1156|  4.12k|    case 3:
  ------------------
  |  Branch (1156:5): [True: 298, False: 3.89k]
  ------------------
 1157|  4.12k|      return true;
 1158|     68|    default:
  ------------------
  |  Branch (1158:5): [True: 68, False: 4.12k]
  ------------------
 1159|     68|      return false;
 1160|  4.19k|  }
 1161|  4.19k|}
_ZN14xmlProtoFuzzer23EntityDecl_Type_IsValidEi:
 1176|  12.4k|bool EntityDecl_Type_IsValid(int value) {
 1177|  12.4k|  switch (value) {
 1178|  8.98k|    case 0:
  ------------------
  |  Branch (1178:5): [True: 8.98k, False: 3.46k]
  ------------------
 1179|  12.3k|    case 1:
  ------------------
  |  Branch (1179:5): [True: 3.36k, False: 9.08k]
  ------------------
 1180|  12.3k|      return true;
 1181|    100|    default:
  ------------------
  |  Branch (1181:5): [True: 100, False: 12.3k]
  ------------------
 1182|    100|      return false;
 1183|  12.4k|  }
 1184|  12.4k|}
_ZN14xmlProtoFuzzer28ConditionalSect_Type_IsValidEi:
 1197|  7.06k|bool ConditionalSect_Type_IsValid(int value) {
 1198|  7.06k|  switch (value) {
 1199|  4.37k|    case 0:
  ------------------
  |  Branch (1199:5): [True: 4.37k, False: 2.68k]
  ------------------
 1200|  5.26k|    case 1:
  ------------------
  |  Branch (1200:5): [True: 882, False: 6.18k]
  ------------------
 1201|  6.84k|    case 2:
  ------------------
  |  Branch (1201:5): [True: 1.58k, False: 5.47k]
  ------------------
 1202|  6.84k|      return true;
 1203|    213|    default:
  ------------------
  |  Branch (1203:5): [True: 213, False: 6.84k]
  ------------------
 1204|    213|      return false;
 1205|  7.06k|  }
 1206|  7.06k|}
_ZN14xmlProtoFuzzer29KeyValue_XmlNamespace_IsValidEi:
 1220|  31.7k|bool KeyValue_XmlNamespace_IsValid(int value) {
 1221|  31.7k|  switch (value) {
 1222|  7.11k|    case 0:
  ------------------
  |  Branch (1222:5): [True: 7.11k, False: 24.6k]
  ------------------
 1223|  8.78k|    case 1:
  ------------------
  |  Branch (1223:5): [True: 1.67k, False: 30.0k]
  ------------------
 1224|  10.3k|    case 2:
  ------------------
  |  Branch (1224:5): [True: 1.52k, False: 30.2k]
  ------------------
 1225|  13.0k|    case 3:
  ------------------
  |  Branch (1225:5): [True: 2.77k, False: 28.9k]
  ------------------
 1226|  16.5k|    case 4:
  ------------------
  |  Branch (1226:5): [True: 3.44k, False: 28.2k]
  ------------------
 1227|  17.6k|    case 5:
  ------------------
  |  Branch (1227:5): [True: 1.12k, False: 30.5k]
  ------------------
 1228|  18.3k|    case 6:
  ------------------
  |  Branch (1228:5): [True: 728, False: 30.9k]
  ------------------
 1229|  19.3k|    case 7:
  ------------------
  |  Branch (1229:5): [True: 967, False: 30.7k]
  ------------------
 1230|  20.8k|    case 8:
  ------------------
  |  Branch (1230:5): [True: 1.46k, False: 30.2k]
  ------------------
 1231|  31.5k|    case 9:
  ------------------
  |  Branch (1231:5): [True: 10.7k, False: 21.0k]
  ------------------
 1232|  31.5k|      return true;
 1233|    196|    default:
  ------------------
  |  Branch (1233:5): [True: 196, False: 31.5k]
  ------------------
 1234|    196|      return false;
 1235|  31.7k|  }
 1236|  31.7k|}
_ZN14xmlProtoFuzzer20Element_Type_IsValidEi:
 1257|   410k|bool Element_Type_IsValid(int value) {
 1258|   410k|  switch (value) {
 1259|   391k|    case 0:
  ------------------
  |  Branch (1259:5): [True: 391k, False: 19.5k]
  ------------------
 1260|   410k|    case 1:
  ------------------
  |  Branch (1260:5): [True: 19.4k, False: 391k]
  ------------------
 1261|   410k|      return true;
 1262|     77|    default:
  ------------------
  |  Branch (1262:5): [True: 77, False: 410k]
  ------------------
 1263|     77|      return false;
 1264|   410k|  }
 1265|   410k|}
_ZN14xmlProtoFuzzer18Element_Id_IsValidEi:
 1278|   391k|bool Element_Id_IsValid(int value) {
 1279|   391k|  switch (value) {
 1280|   372k|    case 0:
  ------------------
  |  Branch (1280:5): [True: 372k, False: 19.0k]
  ------------------
 1281|   374k|    case 1:
  ------------------
  |  Branch (1281:5): [True: 2.65k, False: 388k]
  ------------------
 1282|   380k|    case 2:
  ------------------
  |  Branch (1282:5): [True: 6.15k, False: 385k]
  ------------------
 1283|   382k|    case 3:
  ------------------
  |  Branch (1283:5): [True: 1.66k, False: 389k]
  ------------------
 1284|   383k|    case 4:
  ------------------
  |  Branch (1284:5): [True: 1.10k, False: 390k]
  ------------------
 1285|   386k|    case 5:
  ------------------
  |  Branch (1285:5): [True: 2.78k, False: 388k]
  ------------------
 1286|   389k|    case 6:
  ------------------
  |  Branch (1286:5): [True: 3.03k, False: 388k]
  ------------------
 1287|   390k|    case 7:
  ------------------
  |  Branch (1287:5): [True: 752, False: 390k]
  ------------------
 1288|   390k|      return true;
 1289|    925|    default:
  ------------------
  |  Branch (1289:5): [True: 925, False: 390k]
  ------------------
 1290|    925|      return false;
 1291|   391k|  }
 1292|   391k|}
_ZN14xmlProtoFuzzer23VersionNum_Type_IsValidEi:
 1311|  8.51k|bool VersionNum_Type_IsValid(int value) {
 1312|  8.51k|  switch (value) {
 1313|  8.36k|    case 0:
  ------------------
  |  Branch (1313:5): [True: 8.36k, False: 147]
  ------------------
 1314|  8.51k|    case 1:
  ------------------
  |  Branch (1314:5): [True: 144, False: 8.37k]
  ------------------
 1315|  8.51k|      return true;
 1316|      3|    default:
  ------------------
  |  Branch (1316:5): [True: 3, False: 8.51k]
  ------------------
 1317|      3|      return false;
 1318|  8.51k|  }
 1319|  8.51k|}
_ZN14xmlProtoFuzzer21Encodings_Enc_IsValidEi:
 1332|  8.51k|bool Encodings_Enc_IsValid(int value) {
 1333|  8.51k|  switch (value) {
 1334|  6.79k|    case 0:
  ------------------
  |  Branch (1334:5): [True: 6.79k, False: 1.72k]
  ------------------
 1335|  6.80k|    case 1:
  ------------------
  |  Branch (1335:5): [True: 12, False: 8.50k]
  ------------------
 1336|  6.85k|    case 2:
  ------------------
  |  Branch (1336:5): [True: 53, False: 8.46k]
  ------------------
 1337|  6.86k|    case 3:
  ------------------
  |  Branch (1337:5): [True: 12, False: 8.50k]
  ------------------
 1338|  6.87k|    case 4:
  ------------------
  |  Branch (1338:5): [True: 1, False: 8.51k]
  ------------------
 1339|  6.99k|    case 5:
  ------------------
  |  Branch (1339:5): [True: 123, False: 8.39k]
  ------------------
 1340|  7.06k|    case 6:
  ------------------
  |  Branch (1340:5): [True: 67, False: 8.44k]
  ------------------
 1341|  7.07k|    case 7:
  ------------------
  |  Branch (1341:5): [True: 10, False: 8.50k]
  ------------------
 1342|  7.08k|    case 8:
  ------------------
  |  Branch (1342:5): [True: 12, False: 8.50k]
  ------------------
 1343|  7.09k|    case 9:
  ------------------
  |  Branch (1343:5): [True: 10, False: 8.50k]
  ------------------
 1344|  7.10k|    case 10:
  ------------------
  |  Branch (1344:5): [True: 8, False: 8.50k]
  ------------------
 1345|  7.10k|    case 11:
  ------------------
  |  Branch (1345:5): [True: 4, False: 8.51k]
  ------------------
 1346|  7.10k|    case 12:
  ------------------
  |  Branch (1346:5): [True: 4, False: 8.51k]
  ------------------
 1347|  7.11k|    case 13:
  ------------------
  |  Branch (1347:5): [True: 3, False: 8.51k]
  ------------------
 1348|  7.12k|    case 14:
  ------------------
  |  Branch (1348:5): [True: 14, False: 8.50k]
  ------------------
 1349|  7.23k|    case 15:
  ------------------
  |  Branch (1349:5): [True: 113, False: 8.40k]
  ------------------
 1350|  7.25k|    case 16:
  ------------------
  |  Branch (1350:5): [True: 12, False: 8.50k]
  ------------------
 1351|  7.32k|    case 17:
  ------------------
  |  Branch (1351:5): [True: 74, False: 8.44k]
  ------------------
 1352|  7.40k|    case 18:
  ------------------
  |  Branch (1352:5): [True: 82, False: 8.43k]
  ------------------
 1353|  7.42k|    case 19:
  ------------------
  |  Branch (1353:5): [True: 23, False: 8.49k]
  ------------------
 1354|  7.44k|    case 20:
  ------------------
  |  Branch (1354:5): [True: 14, False: 8.50k]
  ------------------
 1355|  7.45k|    case 21:
  ------------------
  |  Branch (1355:5): [True: 11, False: 8.50k]
  ------------------
 1356|  7.51k|    case 22:
  ------------------
  |  Branch (1356:5): [True: 63, False: 8.45k]
  ------------------
 1357|  7.52k|    case 23:
  ------------------
  |  Branch (1357:5): [True: 6, False: 8.51k]
  ------------------
 1358|  7.52k|    case 24:
  ------------------
  |  Branch (1358:5): [True: 4, False: 8.51k]
  ------------------
 1359|  7.66k|    case 25:
  ------------------
  |  Branch (1359:5): [True: 134, False: 8.38k]
  ------------------
 1360|  7.66k|      return true;
 1361|    855|    default:
  ------------------
  |  Branch (1361:5): [True: 855, False: 7.66k]
  ------------------
 1362|    855|      return false;
 1363|  8.51k|  }
 1364|  8.51k|}
_ZN14xmlProtoFuzzer4MiscC2EPN6google8protobuf5ArenaEb:
 1447|  4.89k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 1448|  4.89k|  SharedCtor(arena, is_message_owned);
 1449|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.Misc)
 1450|  4.89k|}
_ZN14xmlProtoFuzzer4MiscD2Ev:
 1490|  4.89k|Misc::~Misc() {
 1491|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.Misc)
 1492|  4.89k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1492:13): [True: 0, False: 4.89k]
  ------------------
 1493|      0|  (void)arena;
 1494|      0|    return;
 1495|      0|  }
 1496|  4.89k|  SharedDtor();
 1497|  4.89k|}
_ZN14xmlProtoFuzzer4Misc16clear_misc_oneofEv:
 1510|  3.24k|void Misc::clear_misc_oneof() {
 1511|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.Misc)
 1512|  3.24k|  switch (misc_oneof_case()) {
  ------------------
  |  Branch (1512:11): [True: 0, False: 3.24k]
  ------------------
 1513|  1.72k|    case kComment: {
  ------------------
  |  Branch (1513:5): [True: 1.72k, False: 1.51k]
  ------------------
 1514|  1.72k|      _impl_.misc_oneof_.comment_.Destroy();
 1515|  1.72k|      break;
 1516|      0|    }
 1517|  1.51k|    case kInst: {
  ------------------
  |  Branch (1517:5): [True: 1.51k, False: 1.72k]
  ------------------
 1518|  1.51k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (1518:11): [True: 1.51k, False: 0]
  ------------------
 1519|  1.51k|        delete _impl_.misc_oneof_.inst_;
 1520|  1.51k|      }
 1521|  1.51k|      break;
 1522|      0|    }
 1523|      0|    case MISC_ONEOF_NOT_SET: {
  ------------------
  |  Branch (1523:5): [True: 0, False: 3.24k]
  ------------------
 1524|      0|      break;
 1525|      0|    }
 1526|  3.24k|  }
 1527|  3.24k|  _impl_._oneof_case_[0] = MISC_ONEOF_NOT_SET;
 1528|  3.24k|}
_ZNK14xmlProtoFuzzer4Misc11GetMetadataEv:
 1699|  38.1k|::PROTOBUF_NAMESPACE_ID::Metadata Misc::GetMetadata() const {
 1700|  38.1k|  return ::_pbi::AssignDescriptors(
 1701|  38.1k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 1702|  38.1k|      file_level_metadata_xml_2eproto[0]);
 1703|  38.1k|}
_ZN14xmlProtoFuzzer11ElementDeclC2EPN6google8protobuf5ArenaEb:
 1916|  5.73k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 1917|  5.73k|  SharedCtor(arena, is_message_owned);
 1918|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.ElementDecl)
 1919|  5.73k|}
_ZN14xmlProtoFuzzer11ElementDeclD2Ev:
 1958|  5.73k|ElementDecl::~ElementDecl() {
 1959|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.ElementDecl)
 1960|  5.73k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (1960:13): [True: 0, False: 5.73k]
  ------------------
 1961|      0|  (void)arena;
 1962|      0|    return;
 1963|      0|  }
 1964|  5.73k|  SharedDtor();
 1965|  5.73k|}
_ZNK14xmlProtoFuzzer11ElementDecl11GetMetadataEv:
 2174|  76.2k|::PROTOBUF_NAMESPACE_ID::Metadata ElementDecl::GetMetadata() const {
 2175|  76.2k|  return ::_pbi::AssignDescriptors(
 2176|  76.2k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 2177|  76.2k|      file_level_metadata_xml_2eproto[2]);
 2178|  76.2k|}
_ZN14xmlProtoFuzzer10ExternalIdC2EPN6google8protobuf5ArenaEb:
 2891|  7.21k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 2892|  7.21k|  SharedCtor(arena, is_message_owned);
 2893|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.ExternalId)
 2894|  7.21k|}
_ZN14xmlProtoFuzzer10ExternalIdD2Ev:
 2945|  7.21k|ExternalId::~ExternalId() {
 2946|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.ExternalId)
 2947|  7.21k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (2947:13): [True: 0, False: 7.21k]
  ------------------
 2948|      0|  (void)arena;
 2949|      0|    return;
 2950|      0|  }
 2951|  7.21k|  SharedDtor();
 2952|  7.21k|}
_ZNK14xmlProtoFuzzer10ExternalId12ByteSizeLongEv:
 3075|  4.11k|size_t ExternalId::ByteSizeLong() const {
 3076|       |// @@protoc_insertion_point(message_byte_size_start:xmlProtoFuzzer.ExternalId)
 3077|  4.11k|  size_t total_size = 0;
 3078|       |
 3079|  4.11k|  uint32_t cached_has_bits = 0;
 3080|       |  // Prevent compiler warnings about cached_has_bits being unused
 3081|  4.11k|  (void) cached_has_bits;
 3082|       |
 3083|       |  // string system = 2;
 3084|  4.11k|  if (!this->_internal_system().empty()) {
  ------------------
  |  Branch (3084:7): [True: 524, False: 3.59k]
  ------------------
 3085|    524|    total_size += 1 +
 3086|    524|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 3087|    524|        this->_internal_system());
 3088|    524|  }
 3089|       |
 3090|       |  // string pub = 3;
 3091|  4.11k|  if (!this->_internal_pub().empty()) {
  ------------------
  |  Branch (3091:7): [True: 985, False: 3.13k]
  ------------------
 3092|    985|    total_size += 1 +
 3093|    985|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 3094|    985|        this->_internal_pub());
 3095|    985|  }
 3096|       |
 3097|       |  // .xmlProtoFuzzer.ExternalId.Type type = 1;
 3098|  4.11k|  if (this->_internal_type() != 0) {
  ------------------
  |  Branch (3098:7): [True: 1.31k, False: 2.80k]
  ------------------
 3099|  1.31k|    total_size += 1 +
 3100|  1.31k|      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
 3101|  1.31k|  }
 3102|       |
 3103|  4.11k|  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 3104|  4.11k|}
_ZNK14xmlProtoFuzzer10ExternalId11GetMetadataEv:
 3160|  61.2k|::PROTOBUF_NAMESPACE_ID::Metadata ExternalId::GetMetadata() const {
 3161|  61.2k|  return ::_pbi::AssignDescriptors(
 3162|  61.2k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 3163|  61.2k|      file_level_metadata_xml_2eproto[6]);
 3164|  61.2k|}
_ZN14xmlProtoFuzzer8AttValueC2EPN6google8protobuf5ArenaEb:
 3174|  2.69k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 3175|  2.69k|  SharedCtor(arena, is_message_owned);
 3176|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.AttValue)
 3177|  2.69k|}
_ZN14xmlProtoFuzzer8AttValueD2Ev:
 3202|  2.69k|AttValue::~AttValue() {
 3203|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.AttValue)
 3204|  2.69k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3204:13): [True: 0, False: 2.69k]
  ------------------
 3205|      0|  (void)arena;
 3206|      0|    return;
 3207|      0|  }
 3208|  2.69k|  SharedDtor();
 3209|  2.69k|}
_ZNK14xmlProtoFuzzer8AttValue12ByteSizeLongEv:
 3315|  1.05k|size_t AttValue::ByteSizeLong() const {
 3316|       |// @@protoc_insertion_point(message_byte_size_start:xmlProtoFuzzer.AttValue)
 3317|  1.05k|  size_t total_size = 0;
 3318|       |
 3319|  1.05k|  uint32_t cached_has_bits = 0;
 3320|       |  // Prevent compiler warnings about cached_has_bits being unused
 3321|  1.05k|  (void) cached_has_bits;
 3322|       |
 3323|       |  // repeated string value = 2;
 3324|  1.05k|  total_size += 1 *
 3325|  1.05k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.value_.size());
 3326|  2.45k|  for (int i = 0, n = _impl_.value_.size(); i < n; i++) {
  ------------------
  |  Branch (3326:45): [True: 1.40k, False: 1.05k]
  ------------------
 3327|  1.40k|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 3328|  1.40k|      _impl_.value_.Get(i));
 3329|  1.40k|  }
 3330|       |
 3331|       |  // .xmlProtoFuzzer.AttValue.Type type = 1;
 3332|  1.05k|  if (this->_internal_type() != 0) {
  ------------------
  |  Branch (3332:7): [True: 1.05k, False: 0]
  ------------------
 3333|  1.05k|    total_size += 1 +
 3334|  1.05k|      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
 3335|  1.05k|  }
 3336|       |
 3337|  1.05k|  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 3338|  1.05k|}
_ZNK14xmlProtoFuzzer8AttValue11GetMetadataEv:
 3380|  31.5k|::PROTOBUF_NAMESPACE_ID::Metadata AttValue::GetMetadata() const {
 3381|  31.5k|  return ::_pbi::AssignDescriptors(
 3382|  31.5k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 3383|  31.5k|      file_level_metadata_xml_2eproto[7]);
 3384|  31.5k|}
_ZN14xmlProtoFuzzer11DefaultDeclC2EPN6google8protobuf5ArenaEb:
 3399|  4.58k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 3400|  4.58k|  SharedCtor(arena, is_message_owned);
 3401|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.DefaultDecl)
 3402|  4.58k|}
_ZN14xmlProtoFuzzer11DefaultDeclD2Ev:
 3430|  4.58k|DefaultDecl::~DefaultDecl() {
 3431|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.DefaultDecl)
 3432|  4.58k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3432:13): [True: 0, False: 4.58k]
  ------------------
 3433|      0|  (void)arena;
 3434|      0|    return;
 3435|      0|  }
 3436|  4.58k|  SharedDtor();
 3437|  4.58k|}
_ZNK14xmlProtoFuzzer11DefaultDecl11GetMetadataEv:
 3607|  48.6k|::PROTOBUF_NAMESPACE_ID::Metadata DefaultDecl::GetMetadata() const {
 3608|  48.6k|  return ::_pbi::AssignDescriptors(
 3609|  48.6k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 3610|  48.6k|      file_level_metadata_xml_2eproto[8]);
 3611|  48.6k|}
_ZN14xmlProtoFuzzer6AttDefC2EPN6google8protobuf5ArenaEb:
 3626|  19.2k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 3627|  19.2k|  SharedCtor(arena, is_message_owned);
 3628|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.AttDef)
 3629|  19.2k|}
_ZN14xmlProtoFuzzer6AttDefD2Ev:
 3671|  19.2k|AttDef::~AttDef() {
 3672|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.AttDef)
 3673|  19.2k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3673:13): [True: 0, False: 19.2k]
  ------------------
 3674|      0|  (void)arena;
 3675|      0|    return;
 3676|      0|  }
 3677|  19.2k|  SharedDtor();
 3678|  19.2k|}
_ZNK14xmlProtoFuzzer6AttDef11GetMetadataEv:
 3886|   182k|::PROTOBUF_NAMESPACE_ID::Metadata AttDef::GetMetadata() const {
 3887|   182k|  return ::_pbi::AssignDescriptors(
 3888|   182k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 3889|   182k|      file_level_metadata_xml_2eproto[9]);
 3890|   182k|}
_ZN14xmlProtoFuzzer11AttListDeclC2EPN6google8protobuf5ArenaEb:
 3900|  3.92k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 3901|  3.92k|  SharedCtor(arena, is_message_owned);
 3902|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.AttListDecl)
 3903|  3.92k|}
_ZN14xmlProtoFuzzer11AttListDeclD2Ev:
 3939|  3.92k|AttListDecl::~AttListDecl() {
 3940|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.AttListDecl)
 3941|  3.92k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (3941:13): [True: 0, False: 3.92k]
  ------------------
 3942|      0|  (void)arena;
 3943|      0|    return;
 3944|      0|  }
 3945|  3.92k|  SharedDtor();
 3946|  3.92k|}
_ZNK14xmlProtoFuzzer11AttListDecl11GetMetadataEv:
 4123|  85.8k|::PROTOBUF_NAMESPACE_ID::Metadata AttListDecl::GetMetadata() const {
 4124|  85.8k|  return ::_pbi::AssignDescriptors(
 4125|  85.8k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 4126|  85.8k|      file_level_metadata_xml_2eproto[10]);
 4127|  85.8k|}
_ZN14xmlProtoFuzzer12NotationDeclC2EPN6google8protobuf5ArenaEb:
 4157|  5.63k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 4158|  5.63k|  SharedCtor(arena, is_message_owned);
 4159|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.NotationDecl)
 4160|  5.63k|}
_ZN14xmlProtoFuzzer12NotationDeclD2Ev:
 4218|  5.63k|NotationDecl::~NotationDecl() {
 4219|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.NotationDecl)
 4220|  5.63k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (4220:13): [True: 0, False: 5.63k]
  ------------------
 4221|      0|  (void)arena;
 4222|      0|    return;
 4223|      0|  }
 4224|  5.63k|  SharedDtor();
 4225|  5.63k|}
_ZN14xmlProtoFuzzer12NotationDecl20clear_notation_oneofEv:
 4239|  4.54k|void NotationDecl::clear_notation_oneof() {
 4240|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.NotationDecl)
 4241|  4.54k|  switch (notation_oneof_case()) {
  ------------------
  |  Branch (4241:11): [True: 0, False: 4.54k]
  ------------------
 4242|  1.08k|    case kExt: {
  ------------------
  |  Branch (4242:5): [True: 1.08k, False: 3.45k]
  ------------------
 4243|  1.08k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (4243:11): [True: 1.08k, False: 0]
  ------------------
 4244|  1.08k|        delete _impl_.notation_oneof_.ext_;
 4245|  1.08k|      }
 4246|  1.08k|      break;
 4247|      0|    }
 4248|  2.78k|    case kPub: {
  ------------------
  |  Branch (4248:5): [True: 2.78k, False: 1.75k]
  ------------------
 4249|  2.78k|      _impl_.notation_oneof_.pub_.Destroy();
 4250|  2.78k|      break;
 4251|      0|    }
 4252|    670|    case kFuzz: {
  ------------------
  |  Branch (4252:5): [True: 670, False: 3.87k]
  ------------------
 4253|    670|      _impl_.notation_oneof_.fuzz_.Destroy();
 4254|    670|      break;
 4255|      0|    }
 4256|      0|    case NOTATION_ONEOF_NOT_SET: {
  ------------------
  |  Branch (4256:5): [True: 0, False: 4.54k]
  ------------------
 4257|      0|      break;
 4258|      0|    }
 4259|  4.54k|  }
 4260|  4.54k|  _impl_._oneof_case_[0] = NOTATION_ONEOF_NOT_SET;
 4261|  4.54k|}
_ZNK14xmlProtoFuzzer12NotationDecl11GetMetadataEv:
 4500|  49.3k|::PROTOBUF_NAMESPACE_ID::Metadata NotationDecl::GetMetadata() const {
 4501|  49.3k|  return ::_pbi::AssignDescriptors(
 4502|  49.3k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 4503|  49.3k|      file_level_metadata_xml_2eproto[11]);
 4504|  49.3k|}
_ZN14xmlProtoFuzzer11EntityValueC2EPN6google8protobuf5ArenaEb:
 4514|  4.36k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 4515|  4.36k|  SharedCtor(arena, is_message_owned);
 4516|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.EntityValue)
 4517|  4.36k|}
_ZN14xmlProtoFuzzer11EntityValueD2Ev:
 4542|  4.36k|EntityValue::~EntityValue() {
 4543|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.EntityValue)
 4544|  4.36k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (4544:13): [True: 0, False: 4.36k]
  ------------------
 4545|      0|  (void)arena;
 4546|      0|    return;
 4547|      0|  }
 4548|  4.36k|  SharedDtor();
 4549|  4.36k|}
_ZNK14xmlProtoFuzzer11EntityValue12ByteSizeLongEv:
 4655|  1.77k|size_t EntityValue::ByteSizeLong() const {
 4656|       |// @@protoc_insertion_point(message_byte_size_start:xmlProtoFuzzer.EntityValue)
 4657|  1.77k|  size_t total_size = 0;
 4658|       |
 4659|  1.77k|  uint32_t cached_has_bits = 0;
 4660|       |  // Prevent compiler warnings about cached_has_bits being unused
 4661|  1.77k|  (void) cached_has_bits;
 4662|       |
 4663|       |  // repeated string name = 2;
 4664|  1.77k|  total_size += 1 *
 4665|  1.77k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.name_.size());
 4666|  4.97k|  for (int i = 0, n = _impl_.name_.size(); i < n; i++) {
  ------------------
  |  Branch (4666:44): [True: 3.20k, False: 1.77k]
  ------------------
 4667|  3.20k|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 4668|  3.20k|      _impl_.name_.Get(i));
 4669|  3.20k|  }
 4670|       |
 4671|       |  // .xmlProtoFuzzer.EntityValue.Type type = 1;
 4672|  1.77k|  if (this->_internal_type() != 0) {
  ------------------
  |  Branch (4672:7): [True: 1.77k, False: 0]
  ------------------
 4673|  1.77k|    total_size += 1 +
 4674|  1.77k|      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
 4675|  1.77k|  }
 4676|       |
 4677|  1.77k|  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 4678|  1.77k|}
_ZNK14xmlProtoFuzzer11EntityValue11GetMetadataEv:
 4720|  61.1k|::PROTOBUF_NAMESPACE_ID::Metadata EntityValue::GetMetadata() const {
 4721|  61.1k|  return ::_pbi::AssignDescriptors(
 4722|  61.1k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 4723|  61.1k|      file_level_metadata_xml_2eproto[12]);
 4724|  61.1k|}
_ZN14xmlProtoFuzzer9NDataDeclC2EPN6google8protobuf5ArenaEb:
 4734|  1.71k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 4735|  1.71k|  SharedCtor(arena, is_message_owned);
 4736|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.NDataDecl)
 4737|  1.71k|}
_ZN14xmlProtoFuzzer9NDataDeclD2Ev:
 4771|  1.71k|NDataDecl::~NDataDecl() {
 4772|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.NDataDecl)
 4773|  1.71k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (4773:13): [True: 0, False: 1.71k]
  ------------------
 4774|      0|  (void)arena;
 4775|      0|    return;
 4776|      0|  }
 4777|  1.71k|  SharedDtor();
 4778|  1.71k|}
_ZNK14xmlProtoFuzzer9NDataDecl12ByteSizeLongEv:
 4862|  1.44k|size_t NDataDecl::ByteSizeLong() const {
 4863|       |// @@protoc_insertion_point(message_byte_size_start:xmlProtoFuzzer.NDataDecl)
 4864|  1.44k|  size_t total_size = 0;
 4865|       |
 4866|  1.44k|  uint32_t cached_has_bits = 0;
 4867|       |  // Prevent compiler warnings about cached_has_bits being unused
 4868|  1.44k|  (void) cached_has_bits;
 4869|       |
 4870|       |  // string name = 1;
 4871|  1.44k|  if (!this->_internal_name().empty()) {
  ------------------
  |  Branch (4871:7): [True: 858, False: 585]
  ------------------
 4872|    858|    total_size += 1 +
 4873|    858|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 4874|    858|        this->_internal_name());
 4875|    858|  }
 4876|       |
 4877|  1.44k|  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 4878|  1.44k|}
_ZNK14xmlProtoFuzzer9NDataDecl11GetMetadataEv:
 4923|  13.6k|::PROTOBUF_NAMESPACE_ID::Metadata NDataDecl::GetMetadata() const {
 4924|  13.6k|  return ::_pbi::AssignDescriptors(
 4925|  13.6k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 4926|  13.6k|      file_level_metadata_xml_2eproto[13]);
 4927|  13.6k|}
_ZN14xmlProtoFuzzer9EntityDefC2EPN6google8protobuf5ArenaEb:
 4982|  7.68k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 4983|  7.68k|  SharedCtor(arena, is_message_owned);
 4984|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.EntityDef)
 4985|  7.68k|}
_ZN14xmlProtoFuzzer9EntityDefD2Ev:
 5031|  7.68k|EntityDef::~EntityDef() {
 5032|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.EntityDef)
 5033|  7.68k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5033:13): [True: 0, False: 7.68k]
  ------------------
 5034|      0|  (void)arena;
 5035|      0|    return;
 5036|      0|  }
 5037|  7.68k|  SharedDtor();
 5038|  7.68k|}
_ZN14xmlProtoFuzzer9EntityDef18clear_entity_oneofEv:
 5052|  7.08k|void EntityDef::clear_entity_oneof() {
 5053|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.EntityDef)
 5054|  7.08k|  switch (entity_oneof_case()) {
  ------------------
  |  Branch (5054:11): [True: 0, False: 7.08k]
  ------------------
 5055|  4.15k|    case kExt: {
  ------------------
  |  Branch (5055:5): [True: 4.15k, False: 2.92k]
  ------------------
 5056|  4.15k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5056:11): [True: 4.15k, False: 0]
  ------------------
 5057|  4.15k|        delete _impl_.entity_oneof_.ext_;
 5058|  4.15k|      }
 5059|  4.15k|      break;
 5060|      0|    }
 5061|  2.92k|    case kVal: {
  ------------------
  |  Branch (5061:5): [True: 2.92k, False: 4.15k]
  ------------------
 5062|  2.92k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5062:11): [True: 2.92k, False: 0]
  ------------------
 5063|  2.92k|        delete _impl_.entity_oneof_.val_;
 5064|  2.92k|      }
 5065|  2.92k|      break;
 5066|      0|    }
 5067|      0|    case ENTITY_ONEOF_NOT_SET: {
  ------------------
  |  Branch (5067:5): [True: 0, False: 7.08k]
  ------------------
 5068|      0|      break;
 5069|      0|    }
 5070|  7.08k|  }
 5071|  7.08k|  _impl_._oneof_case_[0] = ENTITY_ONEOF_NOT_SET;
 5072|  7.08k|}
_ZNK14xmlProtoFuzzer9EntityDef12ByteSizeLongEv:
 5177|  4.11k|size_t EntityDef::ByteSizeLong() const {
 5178|       |// @@protoc_insertion_point(message_byte_size_start:xmlProtoFuzzer.EntityDef)
 5179|  4.11k|  size_t total_size = 0;
 5180|       |
 5181|  4.11k|  uint32_t cached_has_bits = 0;
 5182|       |  // Prevent compiler warnings about cached_has_bits being unused
 5183|  4.11k|  (void) cached_has_bits;
 5184|       |
 5185|       |  // .xmlProtoFuzzer.NDataDecl ndata = 3;
 5186|  4.11k|  if (this->_internal_has_ndata()) {
  ------------------
  |  Branch (5186:7): [True: 1.44k, False: 2.67k]
  ------------------
 5187|  1.44k|    total_size += 1 +
 5188|  1.44k|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 5189|  1.44k|        *_impl_.ndata_);
 5190|  1.44k|  }
 5191|       |
 5192|  4.11k|  switch (entity_oneof_case()) {
  ------------------
  |  Branch (5192:11): [True: 0, False: 4.11k]
  ------------------
 5193|       |    // .xmlProtoFuzzer.ExternalId ext = 1;
 5194|  4.11k|    case kExt: {
  ------------------
  |  Branch (5194:5): [True: 4.11k, False: 0]
  ------------------
 5195|  4.11k|      total_size += 1 +
 5196|  4.11k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 5197|  4.11k|          *_impl_.entity_oneof_.ext_);
 5198|  4.11k|      break;
 5199|      0|    }
 5200|       |    // .xmlProtoFuzzer.EntityValue val = 2;
 5201|      0|    case kVal: {
  ------------------
  |  Branch (5201:5): [True: 0, False: 4.11k]
  ------------------
 5202|      0|      total_size += 1 +
 5203|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 5204|      0|          *_impl_.entity_oneof_.val_);
 5205|      0|      break;
 5206|      0|    }
 5207|      0|    case ENTITY_ONEOF_NOT_SET: {
  ------------------
  |  Branch (5207:5): [True: 0, False: 4.11k]
  ------------------
 5208|      0|      break;
 5209|      0|    }
 5210|  4.11k|  }
 5211|  4.11k|  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 5212|  4.11k|}
_ZNK14xmlProtoFuzzer9EntityDef11GetMetadataEv:
 5270|  71.2k|::PROTOBUF_NAMESPACE_ID::Metadata EntityDef::GetMetadata() const {
 5271|  71.2k|  return ::_pbi::AssignDescriptors(
 5272|  71.2k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 5273|  71.2k|      file_level_metadata_xml_2eproto[14]);
 5274|  71.2k|}
_ZN14xmlProtoFuzzer5PEDefC2EPN6google8protobuf5ArenaEb:
 5324|  3.42k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 5325|  3.42k|  SharedCtor(arena, is_message_owned);
 5326|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.PEDef)
 5327|  3.42k|}
_ZN14xmlProtoFuzzer5PEDefD2Ev:
 5368|  3.42k|PEDef::~PEDef() {
 5369|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.PEDef)
 5370|  3.42k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5370:13): [True: 0, False: 3.42k]
  ------------------
 5371|      0|  (void)arena;
 5372|      0|    return;
 5373|      0|  }
 5374|  3.42k|  SharedDtor();
 5375|  3.42k|}
_ZN14xmlProtoFuzzer5PEDef17clear_pedef_oneofEv:
 5388|  2.43k|void PEDef::clear_pedef_oneof() {
 5389|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.PEDef)
 5390|  2.43k|  switch (pedef_oneof_case()) {
  ------------------
  |  Branch (5390:11): [True: 0, False: 2.43k]
  ------------------
 5391|  1.43k|    case kVal: {
  ------------------
  |  Branch (5391:5): [True: 1.43k, False: 1.00k]
  ------------------
 5392|  1.43k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5392:11): [True: 1.43k, False: 0]
  ------------------
 5393|  1.43k|        delete _impl_.pedef_oneof_.val_;
 5394|  1.43k|      }
 5395|  1.43k|      break;
 5396|      0|    }
 5397|  1.00k|    case kId: {
  ------------------
  |  Branch (5397:5): [True: 1.00k, False: 1.43k]
  ------------------
 5398|  1.00k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (5398:11): [True: 1.00k, False: 0]
  ------------------
 5399|  1.00k|        delete _impl_.pedef_oneof_.id_;
 5400|  1.00k|      }
 5401|  1.00k|      break;
 5402|      0|    }
 5403|      0|    case PEDEF_ONEOF_NOT_SET: {
  ------------------
  |  Branch (5403:5): [True: 0, False: 2.43k]
  ------------------
 5404|      0|      break;
 5405|      0|    }
 5406|  2.43k|  }
 5407|  2.43k|  _impl_._oneof_case_[0] = PEDEF_ONEOF_NOT_SET;
 5408|  2.43k|}
_ZNK14xmlProtoFuzzer5PEDef11GetMetadataEv:
 5575|  27.9k|::PROTOBUF_NAMESPACE_ID::Metadata PEDef::GetMetadata() const {
 5576|  27.9k|  return ::_pbi::AssignDescriptors(
 5577|  27.9k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 5578|  27.9k|      file_level_metadata_xml_2eproto[15]);
 5579|  27.9k|}
_ZN14xmlProtoFuzzer10EntityDeclC2EPN6google8protobuf5ArenaEb:
 5599|  13.0k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 5600|  13.0k|  SharedCtor(arena, is_message_owned);
 5601|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.EntityDecl)
 5602|  13.0k|}
_ZN14xmlProtoFuzzer10EntityDeclD2Ev:
 5649|  13.0k|EntityDecl::~EntityDecl() {
 5650|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.EntityDecl)
 5651|  13.0k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5651:13): [True: 0, False: 13.0k]
  ------------------
 5652|      0|  (void)arena;
 5653|      0|    return;
 5654|      0|  }
 5655|  13.0k|  SharedDtor();
 5656|  13.0k|}
_ZNK14xmlProtoFuzzer10EntityDecl11GetMetadataEv:
 5895|   140k|::PROTOBUF_NAMESPACE_ID::Metadata EntityDecl::GetMetadata() const {
 5896|   140k|  return ::_pbi::AssignDescriptors(
 5897|   140k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 5898|   140k|      file_level_metadata_xml_2eproto[16]);
 5899|   140k|}
_ZN14xmlProtoFuzzer15ConditionalSectC2EPN6google8protobuf5ArenaEb:
 5914|  7.30k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 5915|  7.30k|  SharedCtor(arena, is_message_owned);
 5916|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.ConditionalSect)
 5917|  7.30k|}
_ZN14xmlProtoFuzzer15ConditionalSectD2Ev:
 5947|  7.30k|ConditionalSect::~ConditionalSect() {
 5948|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.ConditionalSect)
 5949|  7.30k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (5949:13): [True: 0, False: 7.30k]
  ------------------
 5950|      0|  (void)arena;
 5951|      0|    return;
 5952|      0|  }
 5953|  7.30k|  SharedDtor();
 5954|  7.30k|}
_ZNK14xmlProtoFuzzer15ConditionalSect11GetMetadataEv:
 6161|  67.2k|::PROTOBUF_NAMESPACE_ID::Metadata ConditionalSect::GetMetadata() const {
 6162|  67.2k|  return ::_pbi::AssignDescriptors(
 6163|  67.2k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 6164|  67.2k|      file_level_metadata_xml_2eproto[17]);
 6165|  67.2k|}
_ZN14xmlProtoFuzzer16OneExtSubsetDeclC2EPN6google8protobuf5ArenaEb:
 6215|  34.5k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 6216|  34.5k|  SharedCtor(arena, is_message_owned);
 6217|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.OneExtSubsetDecl)
 6218|  34.5k|}
_ZN14xmlProtoFuzzer16OneExtSubsetDeclD2Ev:
 6259|  34.5k|OneExtSubsetDecl::~OneExtSubsetDecl() {
 6260|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.OneExtSubsetDecl)
 6261|  34.5k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (6261:13): [True: 0, False: 34.5k]
  ------------------
 6262|      0|  (void)arena;
 6263|      0|    return;
 6264|      0|  }
 6265|  34.5k|  SharedDtor();
 6266|  34.5k|}
_ZN14xmlProtoFuzzer16OneExtSubsetDecl21clear_extsubset_oneofEv:
 6279|  26.7k|void OneExtSubsetDecl::clear_extsubset_oneof() {
 6280|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.OneExtSubsetDecl)
 6281|  26.7k|  switch (extsubset_oneof_case()) {
  ------------------
  |  Branch (6281:11): [True: 0, False: 26.7k]
  ------------------
 6282|  19.3k|    case kM: {
  ------------------
  |  Branch (6282:5): [True: 19.3k, False: 7.30k]
  ------------------
 6283|  19.3k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6283:11): [True: 19.3k, False: 0]
  ------------------
 6284|  19.3k|        delete _impl_.extsubset_oneof_.m_;
 6285|  19.3k|      }
 6286|  19.3k|      break;
 6287|      0|    }
 6288|  7.30k|    case kC: {
  ------------------
  |  Branch (6288:5): [True: 7.30k, False: 19.3k]
  ------------------
 6289|  7.30k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6289:11): [True: 7.30k, False: 0]
  ------------------
 6290|  7.30k|        delete _impl_.extsubset_oneof_.c_;
 6291|  7.30k|      }
 6292|  7.30k|      break;
 6293|      0|    }
 6294|      0|    case EXTSUBSET_ONEOF_NOT_SET: {
  ------------------
  |  Branch (6294:5): [True: 0, False: 26.7k]
  ------------------
 6295|      0|      break;
 6296|      0|    }
 6297|  26.7k|  }
 6298|  26.7k|  _impl_._oneof_case_[0] = EXTSUBSET_ONEOF_NOT_SET;
 6299|  26.7k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl11GetMetadataEv:
 6466|   283k|::PROTOBUF_NAMESPACE_ID::Metadata OneExtSubsetDecl::GetMetadata() const {
 6467|   283k|  return ::_pbi::AssignDescriptors(
 6468|   283k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 6469|   283k|      file_level_metadata_xml_2eproto[18]);
 6470|   283k|}
_ZN14xmlProtoFuzzer13ExtSubsetDeclC2EPN6google8protobuf5ArenaEb:
 6480|  8.80k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 6481|  8.80k|  SharedCtor(arena, is_message_owned);
 6482|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.ExtSubsetDecl)
 6483|  8.80k|}
_ZN14xmlProtoFuzzer13ExtSubsetDeclD2Ev:
 6505|  8.80k|ExtSubsetDecl::~ExtSubsetDecl() {
 6506|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.ExtSubsetDecl)
 6507|  8.80k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (6507:13): [True: 0, False: 8.80k]
  ------------------
 6508|      0|  (void)arena;
 6509|      0|    return;
 6510|      0|  }
 6511|  8.80k|  SharedDtor();
 6512|  8.80k|}
_ZNK14xmlProtoFuzzer13ExtSubsetDecl11GetMetadataEv:
 6651|   155k|::PROTOBUF_NAMESPACE_ID::Metadata ExtSubsetDecl::GetMetadata() const {
 6652|   155k|  return ::_pbi::AssignDescriptors(
 6653|   155k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 6654|   155k|      file_level_metadata_xml_2eproto[19]);
 6655|   155k|}
_ZN14xmlProtoFuzzer10MarkupDeclC2EPN6google8protobuf5ArenaEb:
 6785|  42.0k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 6786|  42.0k|  SharedCtor(arena, is_message_owned);
 6787|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.MarkupDecl)
 6788|  42.0k|}
_ZN14xmlProtoFuzzer10MarkupDeclD2Ev:
 6849|  42.0k|MarkupDecl::~MarkupDecl() {
 6850|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.MarkupDecl)
 6851|  42.0k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (6851:13): [True: 0, False: 42.0k]
  ------------------
 6852|      0|  (void)arena;
 6853|      0|    return;
 6854|      0|  }
 6855|  42.0k|  SharedDtor();
 6856|  42.0k|}
_ZN14xmlProtoFuzzer10MarkupDecl18clear_markup_oneofEv:
 6869|  35.4k|void MarkupDecl::clear_markup_oneof() {
 6870|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.MarkupDecl)
 6871|  35.4k|  switch (markup_oneof_case()) {
  ------------------
  |  Branch (6871:11): [True: 0, False: 35.4k]
  ------------------
 6872|  5.73k|    case kE: {
  ------------------
  |  Branch (6872:5): [True: 5.73k, False: 29.7k]
  ------------------
 6873|  5.73k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6873:11): [True: 5.73k, False: 0]
  ------------------
 6874|  5.73k|        delete _impl_.markup_oneof_.e_;
 6875|  5.73k|      }
 6876|  5.73k|      break;
 6877|      0|    }
 6878|  3.92k|    case kA: {
  ------------------
  |  Branch (6878:5): [True: 3.92k, False: 31.5k]
  ------------------
 6879|  3.92k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6879:11): [True: 3.92k, False: 0]
  ------------------
 6880|  3.92k|        delete _impl_.markup_oneof_.a_;
 6881|  3.92k|      }
 6882|  3.92k|      break;
 6883|      0|    }
 6884|  5.63k|    case kN: {
  ------------------
  |  Branch (6884:5): [True: 5.63k, False: 29.8k]
  ------------------
 6885|  5.63k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6885:11): [True: 5.63k, False: 0]
  ------------------
 6886|  5.63k|        delete _impl_.markup_oneof_.n_;
 6887|  5.63k|      }
 6888|  5.63k|      break;
 6889|      0|    }
 6890|  1.95k|    case kM: {
  ------------------
  |  Branch (6890:5): [True: 1.95k, False: 33.5k]
  ------------------
 6891|  1.95k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6891:11): [True: 1.95k, False: 0]
  ------------------
 6892|  1.95k|        delete _impl_.markup_oneof_.m_;
 6893|  1.95k|      }
 6894|  1.95k|      break;
 6895|      0|    }
 6896|  13.0k|    case kEntity: {
  ------------------
  |  Branch (6896:5): [True: 13.0k, False: 22.3k]
  ------------------
 6897|  13.0k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6897:11): [True: 13.0k, False: 0]
  ------------------
 6898|  13.0k|        delete _impl_.markup_oneof_.entity_;
 6899|  13.0k|      }
 6900|  13.0k|      break;
 6901|      0|    }
 6902|  5.13k|    case kExt: {
  ------------------
  |  Branch (6902:5): [True: 5.13k, False: 30.3k]
  ------------------
 6903|  5.13k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (6903:11): [True: 5.13k, False: 0]
  ------------------
 6904|  5.13k|        delete _impl_.markup_oneof_.ext_;
 6905|  5.13k|      }
 6906|  5.13k|      break;
 6907|      0|    }
 6908|      0|    case MARKUP_ONEOF_NOT_SET: {
  ------------------
  |  Branch (6908:5): [True: 0, False: 35.4k]
  ------------------
 6909|      0|      break;
 6910|      0|    }
 6911|  35.4k|  }
 6912|  35.4k|  _impl_._oneof_case_[0] = MARKUP_ONEOF_NOT_SET;
 6913|  35.4k|}
_ZNK14xmlProtoFuzzer10MarkupDecl11GetMetadataEv:
 7188|   350k|::PROTOBUF_NAMESPACE_ID::Metadata MarkupDecl::GetMetadata() const {
 7189|   350k|  return ::_pbi::AssignDescriptors(
 7190|   350k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 7191|   350k|      file_level_metadata_xml_2eproto[20]);
 7192|   350k|}
_ZN14xmlProtoFuzzer11DocTypeDeclC2EPN6google8protobuf5ArenaEb:
 7207|  7.75k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 7208|  7.75k|  SharedCtor(arena, is_message_owned);
 7209|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.DocTypeDecl)
 7210|  7.75k|}
_ZN14xmlProtoFuzzer11DocTypeDeclD2Ev:
 7251|  7.75k|DocTypeDecl::~DocTypeDecl() {
 7252|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.DocTypeDecl)
 7253|  7.75k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (7253:13): [True: 0, False: 7.75k]
  ------------------
 7254|      0|  (void)arena;
 7255|      0|    return;
 7256|      0|  }
 7257|  7.75k|  SharedDtor();
 7258|  7.75k|}
_ZNK14xmlProtoFuzzer11DocTypeDecl11GetMetadataEv:
 7467|   117k|::PROTOBUF_NAMESPACE_ID::Metadata DocTypeDecl::GetMetadata() const {
 7468|   117k|  return ::_pbi::AssignDescriptors(
 7469|   117k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 7470|   117k|      file_level_metadata_xml_2eproto[21]);
 7471|   117k|}
_ZN14xmlProtoFuzzer6PrologC2EPN6google8protobuf5ArenaEb:
 7491|  8.20k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 7492|  8.20k|  SharedCtor(arena, is_message_owned);
 7493|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.Prolog)
 7494|  8.20k|}
_ZN14xmlProtoFuzzer6PrologD2Ev:
 7526|  8.20k|Prolog::~Prolog() {
 7527|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.Prolog)
 7528|  8.20k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (7528:13): [True: 0, False: 8.20k]
  ------------------
 7529|      0|  (void)arena;
 7530|      0|    return;
 7531|      0|  }
 7532|  8.20k|  SharedDtor();
 7533|  8.20k|}
_ZNK14xmlProtoFuzzer6Prolog11GetMetadataEv:
 7740|  86.4k|::PROTOBUF_NAMESPACE_ID::Metadata Prolog::GetMetadata() const {
 7741|  86.4k|  return ::_pbi::AssignDescriptors(
 7742|  86.4k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 7743|  86.4k|      file_level_metadata_xml_2eproto[22]);
 7744|  86.4k|}
_ZN14xmlProtoFuzzer8KeyValueC2EPN6google8protobuf5ArenaEb:
 7754|  34.2k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 7755|  34.2k|  SharedCtor(arena, is_message_owned);
 7756|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.KeyValue)
 7757|  34.2k|}
_ZN14xmlProtoFuzzer8KeyValueD2Ev:
 7808|  34.2k|KeyValue::~KeyValue() {
 7809|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.KeyValue)
 7810|  34.2k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (7810:13): [True: 0, False: 34.2k]
  ------------------
 7811|      0|  (void)arena;
 7812|      0|    return;
 7813|      0|  }
 7814|  34.2k|  SharedDtor();
 7815|  34.2k|}
_ZN14xmlProtoFuzzer8KeyValue5ClearEv:
 7827|  1.29k|void KeyValue::Clear() {
 7828|       |// @@protoc_insertion_point(message_clear_start:xmlProtoFuzzer.KeyValue)
 7829|  1.29k|  uint32_t cached_has_bits = 0;
 7830|       |  // Prevent compiler warnings about cached_has_bits being unused
 7831|  1.29k|  (void) cached_has_bits;
 7832|       |
 7833|  1.29k|  _impl_.key_.ClearToEmpty();
 7834|  1.29k|  _impl_.value_.ClearToEmpty();
 7835|  1.29k|  _impl_.type_ = 0;
 7836|  1.29k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 7837|  1.29k|}
_ZNK14xmlProtoFuzzer8KeyValue12ByteSizeLongEv:
 7938|  10.7k|size_t KeyValue::ByteSizeLong() const {
 7939|       |// @@protoc_insertion_point(message_byte_size_start:xmlProtoFuzzer.KeyValue)
 7940|  10.7k|  size_t total_size = 0;
 7941|       |
 7942|  10.7k|  uint32_t cached_has_bits = 0;
 7943|       |  // Prevent compiler warnings about cached_has_bits being unused
 7944|  10.7k|  (void) cached_has_bits;
 7945|       |
 7946|       |  // string key = 2;
 7947|  10.7k|  if (!this->_internal_key().empty()) {
  ------------------
  |  Branch (7947:7): [True: 8.70k, False: 2.01k]
  ------------------
 7948|  8.70k|    total_size += 1 +
 7949|  8.70k|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 7950|  8.70k|        this->_internal_key());
 7951|  8.70k|  }
 7952|       |
 7953|       |  // string value = 3;
 7954|  10.7k|  if (!this->_internal_value().empty()) {
  ------------------
  |  Branch (7954:7): [True: 7.06k, False: 3.65k]
  ------------------
 7955|  7.06k|    total_size += 1 +
 7956|  7.06k|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 7957|  7.06k|        this->_internal_value());
 7958|  7.06k|  }
 7959|       |
 7960|       |  // .xmlProtoFuzzer.KeyValue.XmlNamespace type = 1;
 7961|  10.7k|  if (this->_internal_type() != 0) {
  ------------------
  |  Branch (7961:7): [True: 10.7k, False: 0]
  ------------------
 7962|  10.7k|    total_size += 1 +
 7963|  10.7k|      ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
 7964|  10.7k|  }
 7965|       |
 7966|  10.7k|  return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_);
 7967|  10.7k|}
_ZNK14xmlProtoFuzzer8KeyValue11GetMetadataEv:
 8023|   370k|::PROTOBUF_NAMESPACE_ID::Metadata KeyValue::GetMetadata() const {
 8024|   370k|  return ::_pbi::AssignDescriptors(
 8025|   370k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 8026|   370k|      file_level_metadata_xml_2eproto[23]);
 8027|   370k|}
_ZN14xmlProtoFuzzer21ProcessingInstructionC2EPN6google8protobuf5ArenaEb:
 8037|  1.51k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 8038|  1.51k|  SharedCtor(arena, is_message_owned);
 8039|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.ProcessingInstruction)
 8040|  1.51k|}
_ZN14xmlProtoFuzzer21ProcessingInstructionD2Ev:
 8076|  1.51k|ProcessingInstruction::~ProcessingInstruction() {
 8077|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.ProcessingInstruction)
 8078|  1.51k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (8078:13): [True: 0, False: 1.51k]
  ------------------
 8079|      0|  (void)arena;
 8080|      0|    return;
 8081|      0|  }
 8082|  1.51k|  SharedDtor();
 8083|  1.51k|}
_ZNK14xmlProtoFuzzer21ProcessingInstruction11GetMetadataEv:
 8260|  13.9k|::PROTOBUF_NAMESPACE_ID::Metadata ProcessingInstruction::GetMetadata() const {
 8261|  13.9k|  return ::_pbi::AssignDescriptors(
 8262|  13.9k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 8263|  13.9k|      file_level_metadata_xml_2eproto[24]);
 8264|  13.9k|}
_ZN14xmlProtoFuzzer5CDataC2EPN6google8protobuf5ArenaEb:
 8274|  3.65k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 8275|  3.65k|  SharedCtor(arena, is_message_owned);
 8276|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.CData)
 8277|  3.65k|}
_ZN14xmlProtoFuzzer5CDataD2Ev:
 8311|  3.65k|CData::~CData() {
 8312|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.CData)
 8313|  3.65k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (8313:13): [True: 0, False: 3.65k]
  ------------------
 8314|      0|  (void)arena;
 8315|      0|    return;
 8316|      0|  }
 8317|  3.65k|  SharedDtor();
 8318|  3.65k|}
_ZNK14xmlProtoFuzzer5CData11GetMetadataEv:
 8463|  30.5k|::PROTOBUF_NAMESPACE_ID::Metadata CData::GetMetadata() const {
 8464|  30.5k|  return ::_pbi::AssignDescriptors(
 8465|  30.5k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 8466|  30.5k|      file_level_metadata_xml_2eproto[25]);
 8467|  30.5k|}
_ZN14xmlProtoFuzzer7ContentC2EPN6google8protobuf5ArenaEb:
 8517|  21.2k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 8518|  21.2k|  SharedCtor(arena, is_message_owned);
 8519|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.Content)
 8520|  21.2k|}
_ZN14xmlProtoFuzzer7ContentD2Ev:
 8565|  21.2k|Content::~Content() {
 8566|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.Content)
 8567|  21.2k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (8567:13): [True: 0, False: 21.2k]
  ------------------
 8568|      0|  (void)arena;
 8569|      0|    return;
 8570|      0|  }
 8571|  21.2k|  SharedDtor();
 8572|  21.2k|}
_ZN14xmlProtoFuzzer7Content19clear_content_oneofEv:
 8585|  13.9k|void Content::clear_content_oneof() {
 8586|       |// @@protoc_insertion_point(one_of_clear_start:xmlProtoFuzzer.Content)
 8587|  13.9k|  switch (content_oneof_case()) {
  ------------------
  |  Branch (8587:11): [True: 0, False: 13.9k]
  ------------------
 8588|  2.73k|    case kStr: {
  ------------------
  |  Branch (8588:5): [True: 2.73k, False: 11.2k]
  ------------------
 8589|  2.73k|      _impl_.content_oneof_.str_.Destroy();
 8590|  2.73k|      break;
 8591|      0|    }
 8592|  7.58k|    case kE: {
  ------------------
  |  Branch (8592:5): [True: 7.58k, False: 6.38k]
  ------------------
 8593|  7.58k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (8593:11): [True: 7.58k, False: 0]
  ------------------
 8594|  7.58k|        delete _impl_.content_oneof_.e_;
 8595|  7.58k|      }
 8596|  7.58k|      break;
 8597|      0|    }
 8598|  3.65k|    case kC: {
  ------------------
  |  Branch (8598:5): [True: 3.65k, False: 10.3k]
  ------------------
 8599|  3.65k|      if (GetArenaForAllocation() == nullptr) {
  ------------------
  |  Branch (8599:11): [True: 3.65k, False: 0]
  ------------------
 8600|  3.65k|        delete _impl_.content_oneof_.c_;
 8601|  3.65k|      }
 8602|  3.65k|      break;
 8603|      0|    }
 8604|      0|    case CONTENT_ONEOF_NOT_SET: {
  ------------------
  |  Branch (8604:5): [True: 0, False: 13.9k]
  ------------------
 8605|      0|      break;
 8606|      0|    }
 8607|  13.9k|  }
 8608|  13.9k|  _impl_._oneof_case_[0] = CONTENT_ONEOF_NOT_SET;
 8609|  13.9k|}
_ZNK14xmlProtoFuzzer7Content11GetMetadataEv:
 8807|   156k|::PROTOBUF_NAMESPACE_ID::Metadata Content::GetMetadata() const {
 8808|   156k|  return ::_pbi::AssignDescriptors(
 8809|   156k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 8810|   156k|      file_level_metadata_xml_2eproto[26]);
 8811|   156k|}
_ZN14xmlProtoFuzzer7ElementC2EPN6google8protobuf5ArenaEb:
 8826|   417k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 8827|   417k|  SharedCtor(arena, is_message_owned);
 8828|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.Element)
 8829|   417k|}
_ZN14xmlProtoFuzzer7ElementD2Ev:
 8891|   417k|Element::~Element() {
 8892|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.Element)
 8893|   417k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (8893:13): [True: 0, False: 417k]
  ------------------
 8894|      0|  (void)arena;
 8895|      0|    return;
 8896|      0|  }
 8897|   417k|  SharedDtor();
 8898|   417k|}
_ZN14xmlProtoFuzzer7Element5ClearEv:
 8912|  5.55k|void Element::Clear() {
 8913|       |// @@protoc_insertion_point(message_clear_start:xmlProtoFuzzer.Element)
 8914|  5.55k|  uint32_t cached_has_bits = 0;
 8915|       |  // Prevent compiler warnings about cached_has_bits being unused
 8916|  5.55k|  (void) cached_has_bits;
 8917|       |
 8918|  5.55k|  _impl_.kv_.Clear();
 8919|  5.55k|  _impl_.name_.ClearToEmpty();
 8920|  5.55k|  _impl_.childprop_.ClearToEmpty();
 8921|  5.55k|  if (GetArenaForAllocation() == nullptr && _impl_.content_ != nullptr) {
  ------------------
  |  Branch (8921:7): [True: 5.55k, False: 0]
  |  Branch (8921:45): [True: 1.45k, False: 4.09k]
  ------------------
 8922|  1.45k|    delete _impl_.content_;
 8923|  1.45k|  }
 8924|  5.55k|  _impl_.content_ = nullptr;
 8925|  5.55k|  ::memset(&_impl_.type_, 0, static_cast<size_t>(
 8926|  5.55k|      reinterpret_cast<char*>(&_impl_.id_) -
 8927|  5.55k|      reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.id_));
 8928|  5.55k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
 8929|  5.55k|}
_ZNK14xmlProtoFuzzer7Element11GetMetadataEv:
 9201|  2.96M|::PROTOBUF_NAMESPACE_ID::Metadata Element::GetMetadata() const {
 9202|  2.96M|  return ::_pbi::AssignDescriptors(
 9203|  2.96M|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 9204|  2.96M|      file_level_metadata_xml_2eproto[27]);
 9205|  2.96M|}
_ZN14xmlProtoFuzzer10VersionNumC2EPN6google8protobuf5ArenaEb:
 9215|    224|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 9216|    224|  SharedCtor(arena, is_message_owned);
 9217|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.VersionNum)
 9218|    224|}
_ZN14xmlProtoFuzzer10VersionNumD2Ev:
 9247|    224|VersionNum::~VersionNum() {
 9248|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.VersionNum)
 9249|    224|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (9249:13): [True: 0, False: 224]
  ------------------
 9250|      0|  (void)arena;
 9251|      0|    return;
 9252|      0|  }
 9253|    224|  SharedDtor();
 9254|    224|}
_ZNK14xmlProtoFuzzer10VersionNum11GetMetadataEv:
 9439|  2.85k|::PROTOBUF_NAMESPACE_ID::Metadata VersionNum::GetMetadata() const {
 9440|  2.85k|  return ::_pbi::AssignDescriptors(
 9441|  2.85k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 9442|  2.85k|      file_level_metadata_xml_2eproto[28]);
 9443|  2.85k|}
_ZN14xmlProtoFuzzer9EncodingsC2EPN6google8protobuf5ArenaEb:
 9453|  1.75k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 9454|  1.75k|  SharedCtor(arena, is_message_owned);
 9455|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.Encodings)
 9456|  1.75k|}
_ZN14xmlProtoFuzzer9EncodingsD2Ev:
 9493|  1.75k|Encodings::~Encodings() {
 9494|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.Encodings)
 9495|  1.75k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (9495:13): [True: 0, False: 1.75k]
  ------------------
 9496|      0|  (void)arena;
 9497|      0|    return;
 9498|      0|  }
 9499|  1.75k|  SharedDtor();
 9500|  1.75k|}
_ZNK14xmlProtoFuzzer9Encodings11GetMetadataEv:
 9672|  17.7k|::PROTOBUF_NAMESPACE_ID::Metadata Encodings::GetMetadata() const {
 9673|  17.7k|  return ::_pbi::AssignDescriptors(
 9674|  17.7k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 9675|  17.7k|      file_level_metadata_xml_2eproto[29]);
 9676|  17.7k|}
_ZN14xmlProtoFuzzer14XmlDeclarationC2EPN6google8protobuf5ArenaEb:
 9696|  2.11k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
 9697|  2.11k|  SharedCtor(arena, is_message_owned);
 9698|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.XmlDeclaration)
 9699|  2.11k|}
_ZN14xmlProtoFuzzer14XmlDeclarationD2Ev:
 9746|  2.11k|XmlDeclaration::~XmlDeclaration() {
 9747|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.XmlDeclaration)
 9748|  2.11k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (9748:13): [True: 0, False: 2.11k]
  ------------------
 9749|      0|  (void)arena;
 9750|      0|    return;
 9751|      0|  }
 9752|  2.11k|  SharedDtor();
 9753|  2.11k|}
_ZNK14xmlProtoFuzzer14XmlDeclaration11GetMetadataEv:
 9992|  21.9k|::PROTOBUF_NAMESPACE_ID::Metadata XmlDeclaration::GetMetadata() const {
 9993|  21.9k|  return ::_pbi::AssignDescriptors(
 9994|  21.9k|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
 9995|  21.9k|      file_level_metadata_xml_2eproto[30]);
 9996|  21.9k|}
_ZN14xmlProtoFuzzer11XmlDocumentC2EPN6google8protobuf5ArenaEb:
10011|  8.78k|  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
10012|  8.78k|  SharedCtor(arena, is_message_owned);
10013|       |  // @@protoc_insertion_point(arena_constructor:xmlProtoFuzzer.XmlDocument)
10014|  8.78k|}
_ZN14xmlProtoFuzzer11XmlDocumentD2Ev:
10041|  8.78k|XmlDocument::~XmlDocument() {
10042|       |  // @@protoc_insertion_point(destructor:xmlProtoFuzzer.XmlDocument)
10043|  8.78k|  if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) {
  ------------------
  |  Branch (10043:13): [True: 0, False: 8.78k]
  ------------------
10044|      0|  (void)arena;
10045|      0|    return;
10046|      0|  }
10047|  8.78k|  SharedDtor();
10048|  8.78k|}
_ZN14xmlProtoFuzzer11XmlDocument5ClearEv:
10060|  17.8k|void XmlDocument::Clear() {
10061|       |// @@protoc_insertion_point(message_clear_start:xmlProtoFuzzer.XmlDocument)
10062|  17.8k|  uint32_t cached_has_bits = 0;
10063|       |  // Prevent compiler warnings about cached_has_bits being unused
10064|  17.8k|  (void) cached_has_bits;
10065|       |
10066|  17.8k|  _impl_.e_.Clear();
10067|  17.8k|  if (GetArenaForAllocation() == nullptr && _impl_.p_ != nullptr) {
  ------------------
  |  Branch (10067:7): [True: 17.8k, False: 0]
  |  Branch (10067:45): [True: 216, False: 17.6k]
  ------------------
10068|    216|    delete _impl_.p_;
10069|    216|  }
10070|  17.8k|  _impl_.p_ = nullptr;
10071|  17.8k|  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
10072|  17.8k|}
_ZNK14xmlProtoFuzzer11XmlDocument11GetMetadataEv:
10219|  1.31M|::PROTOBUF_NAMESPACE_ID::Metadata XmlDocument::GetMetadata() const {
10220|  1.31M|  return ::_pbi::AssignDescriptors(
10221|  1.31M|      &descriptor_table_xml_2eproto_getter, &descriptor_table_xml_2eproto_once,
10222|  1.31M|      file_level_metadata_xml_2eproto[31]);
10223|  1.31M|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer4MiscEJEEEPT_PS1_DpOT0_:
10229|  4.89k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::Misc >(Arena* arena) {
10230|  4.89k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::Misc >(arena);
10231|  4.89k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer11ElementDeclEJEEEPT_PS1_DpOT0_:
10237|  5.73k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::ElementDecl >(Arena* arena) {
10238|  5.73k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::ElementDecl >(arena);
10239|  5.73k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer10ExternalIdEJEEEPT_PS1_DpOT0_:
10253|  7.21k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::ExternalId >(Arena* arena) {
10254|  7.21k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::ExternalId >(arena);
10255|  7.21k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer8AttValueEJEEEPT_PS1_DpOT0_:
10257|  2.69k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::AttValue >(Arena* arena) {
10258|  2.69k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::AttValue >(arena);
10259|  2.69k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer11DefaultDeclEJEEEPT_PS1_DpOT0_:
10261|  4.58k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::DefaultDecl >(Arena* arena) {
10262|  4.58k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::DefaultDecl >(arena);
10263|  4.58k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer6AttDefEJEEEPT_PS1_DpOT0_:
10265|  19.2k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::AttDef >(Arena* arena) {
10266|  19.2k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::AttDef >(arena);
10267|  19.2k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer11AttListDeclEJEEEPT_PS1_DpOT0_:
10269|  3.92k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::AttListDecl >(Arena* arena) {
10270|  3.92k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::AttListDecl >(arena);
10271|  3.92k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer12NotationDeclEJEEEPT_PS1_DpOT0_:
10273|  5.63k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::NotationDecl >(Arena* arena) {
10274|  5.63k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::NotationDecl >(arena);
10275|  5.63k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer11EntityValueEJEEEPT_PS1_DpOT0_:
10277|  4.36k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::EntityValue >(Arena* arena) {
10278|  4.36k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::EntityValue >(arena);
10279|  4.36k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer9NDataDeclEJEEEPT_PS1_DpOT0_:
10281|  1.71k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::NDataDecl >(Arena* arena) {
10282|  1.71k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::NDataDecl >(arena);
10283|  1.71k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer9EntityDefEJEEEPT_PS1_DpOT0_:
10285|  7.68k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::EntityDef >(Arena* arena) {
10286|  7.68k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::EntityDef >(arena);
10287|  7.68k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer5PEDefEJEEEPT_PS1_DpOT0_:
10289|  3.42k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::PEDef >(Arena* arena) {
10290|  3.42k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::PEDef >(arena);
10291|  3.42k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer10EntityDeclEJEEEPT_PS1_DpOT0_:
10293|  13.0k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::EntityDecl >(Arena* arena) {
10294|  13.0k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::EntityDecl >(arena);
10295|  13.0k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer15ConditionalSectEJEEEPT_PS1_DpOT0_:
10297|  7.30k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::ConditionalSect >(Arena* arena) {
10298|  7.30k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::ConditionalSect >(arena);
10299|  7.30k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer16OneExtSubsetDeclEJEEEPT_PS1_DpOT0_:
10301|  34.5k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::OneExtSubsetDecl >(Arena* arena) {
10302|  34.5k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::OneExtSubsetDecl >(arena);
10303|  34.5k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer13ExtSubsetDeclEJEEEPT_PS1_DpOT0_:
10305|  8.80k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::ExtSubsetDecl >(Arena* arena) {
10306|  8.80k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::ExtSubsetDecl >(arena);
10307|  8.80k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer10MarkupDeclEJEEEPT_PS1_DpOT0_:
10309|  42.0k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::MarkupDecl >(Arena* arena) {
10310|  42.0k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::MarkupDecl >(arena);
10311|  42.0k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer11DocTypeDeclEJEEEPT_PS1_DpOT0_:
10313|  7.75k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::DocTypeDecl >(Arena* arena) {
10314|  7.75k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::DocTypeDecl >(arena);
10315|  7.75k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer6PrologEJEEEPT_PS1_DpOT0_:
10317|  8.20k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::Prolog >(Arena* arena) {
10318|  8.20k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::Prolog >(arena);
10319|  8.20k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer8KeyValueEJEEEPT_PS1_DpOT0_:
10321|  34.2k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::KeyValue >(Arena* arena) {
10322|  34.2k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::KeyValue >(arena);
10323|  34.2k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer21ProcessingInstructionEJEEEPT_PS1_DpOT0_:
10325|  1.51k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::ProcessingInstruction >(Arena* arena) {
10326|  1.51k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::ProcessingInstruction >(arena);
10327|  1.51k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer5CDataEJEEEPT_PS1_DpOT0_:
10329|  3.65k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::CData >(Arena* arena) {
10330|  3.65k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::CData >(arena);
10331|  3.65k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer7ContentEJEEEPT_PS1_DpOT0_:
10333|  21.2k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::Content >(Arena* arena) {
10334|  21.2k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::Content >(arena);
10335|  21.2k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer7ElementEJEEEPT_PS1_DpOT0_:
10337|   417k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::Element >(Arena* arena) {
10338|   417k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::Element >(arena);
10339|   417k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer10VersionNumEJEEEPT_PS1_DpOT0_:
10341|    224|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::VersionNum >(Arena* arena) {
10342|    224|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::VersionNum >(arena);
10343|    224|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer9EncodingsEJEEEPT_PS1_DpOT0_:
10345|  1.75k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::Encodings >(Arena* arena) {
10346|  1.75k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::Encodings >(arena);
10347|  1.75k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN14xmlProtoFuzzer14XmlDeclarationEJEEEPT_PS1_DpOT0_:
10349|  2.11k|Arena::CreateMaybeMessage< ::xmlProtoFuzzer::XmlDeclaration >(Arena* arena) {
10350|  2.11k|  return Arena::CreateMessageInternal< ::xmlProtoFuzzer::XmlDeclaration >(arena);
10351|  2.11k|}
_ZN14xmlProtoFuzzer4Misc10SharedCtorEPN6google8protobuf5ArenaEb:
 1479|  4.89k|    ::_pb::Arena* arena, bool is_message_owned) {
 1480|  4.89k|  (void)arena;
 1481|  4.89k|  (void)is_message_owned;
 1482|  4.89k|  new (&_impl_) Impl_{
 1483|  4.89k|      decltype(_impl_.misc_oneof_){}
 1484|  4.89k|    , /*decltype(_impl_._cached_size_)*/{}
 1485|  4.89k|    , /*decltype(_impl_._oneof_case_)*/{}
 1486|  4.89k|  };
 1487|  4.89k|  clear_has_misc_oneof();
 1488|  4.89k|}
_ZN14xmlProtoFuzzer4Misc10SharedDtorEv:
 1499|  4.89k|inline void Misc::SharedDtor() {
 1500|  4.89k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  4.89k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1501|  4.89k|  if (has_misc_oneof()) {
  ------------------
  |  Branch (1501:7): [True: 3.24k, False: 1.64k]
  ------------------
 1502|  3.24k|    clear_misc_oneof();
 1503|  3.24k|  }
 1504|  4.89k|}
_ZN14xmlProtoFuzzer11ElementDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 1943|  5.73k|    ::_pb::Arena* arena, bool is_message_owned) {
 1944|  5.73k|  (void)arena;
 1945|  5.73k|  (void)is_message_owned;
 1946|  5.73k|  new (&_impl_) Impl_{
 1947|  5.73k|      decltype(_impl_.cdata_){arena}
 1948|  5.73k|    , decltype(_impl_.name_){}
 1949|  5.73k|    , decltype(_impl_.spec_){0}
 1950|  5.73k|    , /*decltype(_impl_._cached_size_)*/{}
 1951|  5.73k|  };
 1952|  5.73k|  _impl_.name_.InitDefault();
 1953|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1954|       |    _impl_.name_.Set("", GetArenaForAllocation());
 1955|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 1956|  5.73k|}
_ZN14xmlProtoFuzzer11ElementDecl10SharedDtorEv:
 1967|  5.73k|inline void ElementDecl::SharedDtor() {
 1968|  5.73k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  5.73k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 1969|  5.73k|  _impl_.cdata_.~RepeatedPtrField();
 1970|  5.73k|  _impl_.name_.Destroy();
 1971|  5.73k|}
_ZN14xmlProtoFuzzer10ExternalId10SharedCtorEPN6google8protobuf5ArenaEb:
 2926|  7.21k|    ::_pb::Arena* arena, bool is_message_owned) {
 2927|  7.21k|  (void)arena;
 2928|  7.21k|  (void)is_message_owned;
 2929|  7.21k|  new (&_impl_) Impl_{
 2930|  7.21k|      decltype(_impl_.system_){}
 2931|  7.21k|    , decltype(_impl_.pub_){}
 2932|  7.21k|    , decltype(_impl_.type_){0}
 2933|  7.21k|    , /*decltype(_impl_._cached_size_)*/{}
 2934|  7.21k|  };
 2935|  7.21k|  _impl_.system_.InitDefault();
 2936|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2937|       |    _impl_.system_.Set("", GetArenaForAllocation());
 2938|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2939|  7.21k|  _impl_.pub_.InitDefault();
 2940|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2941|       |    _impl_.pub_.Set("", GetArenaForAllocation());
 2942|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 2943|  7.21k|}
_ZN14xmlProtoFuzzer10ExternalId10SharedDtorEv:
 2954|  7.21k|inline void ExternalId::SharedDtor() {
 2955|  7.21k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  7.21k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 2956|  7.21k|  _impl_.system_.Destroy();
 2957|  7.21k|  _impl_.pub_.Destroy();
 2958|  7.21k|}
_ZN14xmlProtoFuzzer8AttValue10SharedCtorEPN6google8protobuf5ArenaEb:
 3192|  2.69k|    ::_pb::Arena* arena, bool is_message_owned) {
 3193|  2.69k|  (void)arena;
 3194|  2.69k|  (void)is_message_owned;
 3195|  2.69k|  new (&_impl_) Impl_{
 3196|  2.69k|      decltype(_impl_.value_){arena}
 3197|  2.69k|    , decltype(_impl_.type_){0}
 3198|  2.69k|    , /*decltype(_impl_._cached_size_)*/{}
 3199|  2.69k|  };
 3200|  2.69k|}
_ZN14xmlProtoFuzzer8AttValue10SharedDtorEv:
 3211|  2.69k|inline void AttValue::SharedDtor() {
 3212|  2.69k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  2.69k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3213|  2.69k|  _impl_.value_.~RepeatedPtrField();
 3214|  2.69k|}
_ZN14xmlProtoFuzzer11DefaultDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 3420|  4.58k|    ::_pb::Arena* arena, bool is_message_owned) {
 3421|  4.58k|  (void)arena;
 3422|  4.58k|  (void)is_message_owned;
 3423|  4.58k|  new (&_impl_) Impl_{
 3424|  4.58k|      decltype(_impl_.att_){nullptr}
 3425|  4.58k|    , decltype(_impl_.type_){0}
 3426|  4.58k|    , /*decltype(_impl_._cached_size_)*/{}
 3427|  4.58k|  };
 3428|  4.58k|}
_ZN14xmlProtoFuzzer11DefaultDecl10SharedDtorEv:
 3439|  4.58k|inline void DefaultDecl::SharedDtor() {
 3440|  4.58k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  4.58k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3441|  4.58k|  if (this != internal_default_instance()) delete _impl_.att_;
  ------------------
  |  Branch (3441:7): [True: 4.58k, False: 0]
  ------------------
 3442|  4.58k|}
_ZN14xmlProtoFuzzer6AttDef10SharedCtorEPN6google8protobuf5ArenaEb:
 3656|  19.2k|    ::_pb::Arena* arena, bool is_message_owned) {
 3657|  19.2k|  (void)arena;
 3658|  19.2k|  (void)is_message_owned;
 3659|  19.2k|  new (&_impl_) Impl_{
 3660|  19.2k|      decltype(_impl_.name_){}
 3661|  19.2k|    , decltype(_impl_.def_){nullptr}
 3662|  19.2k|    , decltype(_impl_.type_){0}
 3663|  19.2k|    , /*decltype(_impl_._cached_size_)*/{}
 3664|  19.2k|  };
 3665|  19.2k|  _impl_.name_.InitDefault();
 3666|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 3667|       |    _impl_.name_.Set("", GetArenaForAllocation());
 3668|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 3669|  19.2k|}
_ZN14xmlProtoFuzzer6AttDef10SharedDtorEv:
 3680|  19.2k|inline void AttDef::SharedDtor() {
 3681|  19.2k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  19.2k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3682|  19.2k|  _impl_.name_.Destroy();
 3683|  19.2k|  if (this != internal_default_instance()) delete _impl_.def_;
  ------------------
  |  Branch (3683:7): [True: 19.2k, False: 0]
  ------------------
 3684|  19.2k|}
_ZN14xmlProtoFuzzer11AttListDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 3925|  3.92k|    ::_pb::Arena* arena, bool is_message_owned) {
 3926|  3.92k|  (void)arena;
 3927|  3.92k|  (void)is_message_owned;
 3928|  3.92k|  new (&_impl_) Impl_{
 3929|  3.92k|      decltype(_impl_.attdefs_){arena}
 3930|  3.92k|    , decltype(_impl_.name_){}
 3931|  3.92k|    , /*decltype(_impl_._cached_size_)*/{}
 3932|  3.92k|  };
 3933|  3.92k|  _impl_.name_.InitDefault();
 3934|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 3935|       |    _impl_.name_.Set("", GetArenaForAllocation());
 3936|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 3937|  3.92k|}
_ZN14xmlProtoFuzzer11AttListDecl10SharedDtorEv:
 3948|  3.92k|inline void AttListDecl::SharedDtor() {
 3949|  3.92k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  3.92k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 3950|  3.92k|  _impl_.attdefs_.~RepeatedPtrField();
 3951|  3.92k|  _impl_.name_.Destroy();
 3952|  3.92k|}
_ZN14xmlProtoFuzzer12NotationDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 4202|  5.63k|    ::_pb::Arena* arena, bool is_message_owned) {
 4203|  5.63k|  (void)arena;
 4204|  5.63k|  (void)is_message_owned;
 4205|  5.63k|  new (&_impl_) Impl_{
 4206|  5.63k|      decltype(_impl_.name_){}
 4207|  5.63k|    , decltype(_impl_.notation_oneof_){}
 4208|  5.63k|    , /*decltype(_impl_._cached_size_)*/{}
 4209|  5.63k|    , /*decltype(_impl_._oneof_case_)*/{}
 4210|  5.63k|  };
 4211|  5.63k|  _impl_.name_.InitDefault();
 4212|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4213|       |    _impl_.name_.Set("", GetArenaForAllocation());
 4214|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4215|  5.63k|  clear_has_notation_oneof();
 4216|  5.63k|}
_ZN14xmlProtoFuzzer12NotationDecl10SharedDtorEv:
 4227|  5.63k|inline void NotationDecl::SharedDtor() {
 4228|  5.63k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  5.63k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 4229|  5.63k|  _impl_.name_.Destroy();
 4230|  5.63k|  if (has_notation_oneof()) {
  ------------------
  |  Branch (4230:7): [True: 4.54k, False: 1.09k]
  ------------------
 4231|  4.54k|    clear_notation_oneof();
 4232|  4.54k|  }
 4233|  5.63k|}
_ZN14xmlProtoFuzzer11EntityValue10SharedCtorEPN6google8protobuf5ArenaEb:
 4532|  4.36k|    ::_pb::Arena* arena, bool is_message_owned) {
 4533|  4.36k|  (void)arena;
 4534|  4.36k|  (void)is_message_owned;
 4535|  4.36k|  new (&_impl_) Impl_{
 4536|  4.36k|      decltype(_impl_.name_){arena}
 4537|  4.36k|    , decltype(_impl_.type_){0}
 4538|  4.36k|    , /*decltype(_impl_._cached_size_)*/{}
 4539|  4.36k|  };
 4540|  4.36k|}
_ZN14xmlProtoFuzzer11EntityValue10SharedDtorEv:
 4551|  4.36k|inline void EntityValue::SharedDtor() {
 4552|  4.36k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  4.36k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 4553|  4.36k|  _impl_.name_.~RepeatedPtrField();
 4554|  4.36k|}
_ZN14xmlProtoFuzzer9NDataDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 4758|  1.71k|    ::_pb::Arena* arena, bool is_message_owned) {
 4759|  1.71k|  (void)arena;
 4760|  1.71k|  (void)is_message_owned;
 4761|  1.71k|  new (&_impl_) Impl_{
 4762|  1.71k|      decltype(_impl_.name_){}
 4763|  1.71k|    , /*decltype(_impl_._cached_size_)*/{}
 4764|  1.71k|  };
 4765|  1.71k|  _impl_.name_.InitDefault();
 4766|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4767|       |    _impl_.name_.Set("", GetArenaForAllocation());
 4768|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 4769|  1.71k|}
_ZN14xmlProtoFuzzer9NDataDecl10SharedDtorEv:
 4780|  1.71k|inline void NDataDecl::SharedDtor() {
 4781|  1.71k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  1.71k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 4782|  1.71k|  _impl_.name_.Destroy();
 4783|  1.71k|}
_ZN14xmlProtoFuzzer9EntityDef10SharedCtorEPN6google8protobuf5ArenaEb:
 5019|  7.68k|    ::_pb::Arena* arena, bool is_message_owned) {
 5020|  7.68k|  (void)arena;
 5021|  7.68k|  (void)is_message_owned;
 5022|  7.68k|  new (&_impl_) Impl_{
 5023|  7.68k|      decltype(_impl_.ndata_){nullptr}
 5024|  7.68k|    , decltype(_impl_.entity_oneof_){}
 5025|  7.68k|    , /*decltype(_impl_._cached_size_)*/{}
 5026|  7.68k|    , /*decltype(_impl_._oneof_case_)*/{}
 5027|  7.68k|  };
 5028|  7.68k|  clear_has_entity_oneof();
 5029|  7.68k|}
_ZN14xmlProtoFuzzer9EntityDef10SharedDtorEv:
 5040|  7.68k|inline void EntityDef::SharedDtor() {
 5041|  7.68k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  7.68k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 5042|  7.68k|  if (this != internal_default_instance()) delete _impl_.ndata_;
  ------------------
  |  Branch (5042:7): [True: 7.68k, False: 0]
  ------------------
 5043|  7.68k|  if (has_entity_oneof()) {
  ------------------
  |  Branch (5043:7): [True: 7.08k, False: 604]
  ------------------
 5044|  7.08k|    clear_entity_oneof();
 5045|  7.08k|  }
 5046|  7.68k|}
_ZN14xmlProtoFuzzer5PEDef10SharedCtorEPN6google8protobuf5ArenaEb:
 5357|  3.42k|    ::_pb::Arena* arena, bool is_message_owned) {
 5358|  3.42k|  (void)arena;
 5359|  3.42k|  (void)is_message_owned;
 5360|  3.42k|  new (&_impl_) Impl_{
 5361|  3.42k|      decltype(_impl_.pedef_oneof_){}
 5362|  3.42k|    , /*decltype(_impl_._cached_size_)*/{}
 5363|  3.42k|    , /*decltype(_impl_._oneof_case_)*/{}
 5364|  3.42k|  };
 5365|  3.42k|  clear_has_pedef_oneof();
 5366|  3.42k|}
_ZN14xmlProtoFuzzer5PEDef10SharedDtorEv:
 5377|  3.42k|inline void PEDef::SharedDtor() {
 5378|  3.42k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  3.42k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 5379|  3.42k|  if (has_pedef_oneof()) {
  ------------------
  |  Branch (5379:7): [True: 2.43k, False: 988]
  ------------------
 5380|  2.43k|    clear_pedef_oneof();
 5381|  2.43k|  }
 5382|  3.42k|}
_ZN14xmlProtoFuzzer10EntityDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 5633|  13.0k|    ::_pb::Arena* arena, bool is_message_owned) {
 5634|  13.0k|  (void)arena;
 5635|  13.0k|  (void)is_message_owned;
 5636|  13.0k|  new (&_impl_) Impl_{
 5637|  13.0k|      decltype(_impl_.name_){}
 5638|  13.0k|    , decltype(_impl_.ent_){nullptr}
 5639|  13.0k|    , decltype(_impl_.pedef_){nullptr}
 5640|  13.0k|    , decltype(_impl_.type_){0}
 5641|  13.0k|    , /*decltype(_impl_._cached_size_)*/{}
 5642|  13.0k|  };
 5643|  13.0k|  _impl_.name_.InitDefault();
 5644|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5645|       |    _impl_.name_.Set("", GetArenaForAllocation());
 5646|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 5647|  13.0k|}
_ZN14xmlProtoFuzzer10EntityDecl10SharedDtorEv:
 5658|  13.0k|inline void EntityDecl::SharedDtor() {
 5659|  13.0k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  13.0k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 5660|  13.0k|  _impl_.name_.Destroy();
 5661|  13.0k|  if (this != internal_default_instance()) delete _impl_.ent_;
  ------------------
  |  Branch (5661:7): [True: 13.0k, False: 0]
  ------------------
 5662|  13.0k|  if (this != internal_default_instance()) delete _impl_.pedef_;
  ------------------
  |  Branch (5662:7): [True: 13.0k, False: 0]
  ------------------
 5663|  13.0k|}
_ZN14xmlProtoFuzzer15ConditionalSect10SharedCtorEPN6google8protobuf5ArenaEb:
 5936|  7.30k|    ::_pb::Arena* arena, bool is_message_owned) {
 5937|  7.30k|  (void)arena;
 5938|  7.30k|  (void)is_message_owned;
 5939|  7.30k|  new (&_impl_) Impl_{
 5940|  7.30k|      decltype(_impl_.ignores_){arena}
 5941|  7.30k|    , decltype(_impl_.ext_){nullptr}
 5942|  7.30k|    , decltype(_impl_.type_){0}
 5943|  7.30k|    , /*decltype(_impl_._cached_size_)*/{}
 5944|  7.30k|  };
 5945|  7.30k|}
_ZN14xmlProtoFuzzer15ConditionalSect10SharedDtorEv:
 5956|  7.30k|inline void ConditionalSect::SharedDtor() {
 5957|  7.30k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  7.30k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 5958|  7.30k|  _impl_.ignores_.~RepeatedPtrField();
 5959|  7.30k|  if (this != internal_default_instance()) delete _impl_.ext_;
  ------------------
  |  Branch (5959:7): [True: 7.30k, False: 0]
  ------------------
 5960|  7.30k|}
_ZN14xmlProtoFuzzer16OneExtSubsetDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 6248|  34.5k|    ::_pb::Arena* arena, bool is_message_owned) {
 6249|  34.5k|  (void)arena;
 6250|  34.5k|  (void)is_message_owned;
 6251|  34.5k|  new (&_impl_) Impl_{
 6252|  34.5k|      decltype(_impl_.extsubset_oneof_){}
 6253|  34.5k|    , /*decltype(_impl_._cached_size_)*/{}
 6254|  34.5k|    , /*decltype(_impl_._oneof_case_)*/{}
 6255|  34.5k|  };
 6256|  34.5k|  clear_has_extsubset_oneof();
 6257|  34.5k|}
_ZN14xmlProtoFuzzer16OneExtSubsetDecl10SharedDtorEv:
 6268|  34.5k|inline void OneExtSubsetDecl::SharedDtor() {
 6269|  34.5k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  34.5k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6270|  34.5k|  if (has_extsubset_oneof()) {
  ------------------
  |  Branch (6270:7): [True: 26.7k, False: 7.84k]
  ------------------
 6271|  26.7k|    clear_extsubset_oneof();
 6272|  26.7k|  }
 6273|  34.5k|}
_ZN14xmlProtoFuzzer13ExtSubsetDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 6496|  8.80k|    ::_pb::Arena* arena, bool is_message_owned) {
 6497|  8.80k|  (void)arena;
 6498|  8.80k|  (void)is_message_owned;
 6499|  8.80k|  new (&_impl_) Impl_{
 6500|  8.80k|      decltype(_impl_.decls_){arena}
 6501|  8.80k|    , /*decltype(_impl_._cached_size_)*/{}
 6502|  8.80k|  };
 6503|  8.80k|}
_ZN14xmlProtoFuzzer13ExtSubsetDecl10SharedDtorEv:
 6514|  8.80k|inline void ExtSubsetDecl::SharedDtor() {
 6515|  8.80k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  8.80k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6516|  8.80k|  _impl_.decls_.~RepeatedPtrField();
 6517|  8.80k|}
_ZN14xmlProtoFuzzer10MarkupDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 6838|  42.0k|    ::_pb::Arena* arena, bool is_message_owned) {
 6839|  42.0k|  (void)arena;
 6840|  42.0k|  (void)is_message_owned;
 6841|  42.0k|  new (&_impl_) Impl_{
 6842|  42.0k|      decltype(_impl_.markup_oneof_){}
 6843|  42.0k|    , /*decltype(_impl_._cached_size_)*/{}
 6844|  42.0k|    , /*decltype(_impl_._oneof_case_)*/{}
 6845|  42.0k|  };
 6846|  42.0k|  clear_has_markup_oneof();
 6847|  42.0k|}
_ZN14xmlProtoFuzzer10MarkupDecl10SharedDtorEv:
 6858|  42.0k|inline void MarkupDecl::SharedDtor() {
 6859|  42.0k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  42.0k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 6860|  42.0k|  if (has_markup_oneof()) {
  ------------------
  |  Branch (6860:7): [True: 35.4k, False: 6.54k]
  ------------------
 6861|  35.4k|    clear_markup_oneof();
 6862|  35.4k|  }
 6863|  42.0k|}
_ZN14xmlProtoFuzzer11DocTypeDecl10SharedCtorEPN6google8protobuf5ArenaEb:
 7236|  7.75k|    ::_pb::Arena* arena, bool is_message_owned) {
 7237|  7.75k|  (void)arena;
 7238|  7.75k|  (void)is_message_owned;
 7239|  7.75k|  new (&_impl_) Impl_{
 7240|  7.75k|      decltype(_impl_.mdecl_){arena}
 7241|  7.75k|    , decltype(_impl_.name_){}
 7242|  7.75k|    , decltype(_impl_.ext_){nullptr}
 7243|  7.75k|    , /*decltype(_impl_._cached_size_)*/{}
 7244|  7.75k|  };
 7245|  7.75k|  _impl_.name_.InitDefault();
 7246|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7247|       |    _impl_.name_.Set("", GetArenaForAllocation());
 7248|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7249|  7.75k|}
_ZN14xmlProtoFuzzer11DocTypeDecl10SharedDtorEv:
 7260|  7.75k|inline void DocTypeDecl::SharedDtor() {
 7261|  7.75k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  7.75k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 7262|  7.75k|  _impl_.mdecl_.~RepeatedPtrField();
 7263|  7.75k|  _impl_.name_.Destroy();
 7264|  7.75k|  if (this != internal_default_instance()) delete _impl_.ext_;
  ------------------
  |  Branch (7264:7): [True: 7.75k, False: 0]
  ------------------
 7265|  7.75k|}
_ZN14xmlProtoFuzzer6Prolog10SharedCtorEPN6google8protobuf5ArenaEb:
 7515|  8.20k|    ::_pb::Arena* arena, bool is_message_owned) {
 7516|  8.20k|  (void)arena;
 7517|  8.20k|  (void)is_message_owned;
 7518|  8.20k|  new (&_impl_) Impl_{
 7519|  8.20k|      decltype(_impl_.misc_){arena}
 7520|  8.20k|    , decltype(_impl_.decl_){nullptr}
 7521|  8.20k|    , decltype(_impl_.doctype_){nullptr}
 7522|  8.20k|    , /*decltype(_impl_._cached_size_)*/{}
 7523|  8.20k|  };
 7524|  8.20k|}
_ZN14xmlProtoFuzzer6Prolog10SharedDtorEv:
 7535|  8.20k|inline void Prolog::SharedDtor() {
 7536|  8.20k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  8.20k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 7537|  8.20k|  _impl_.misc_.~RepeatedPtrField();
 7538|  8.20k|  if (this != internal_default_instance()) delete _impl_.decl_;
  ------------------
  |  Branch (7538:7): [True: 8.20k, False: 0]
  ------------------
 7539|  8.20k|  if (this != internal_default_instance()) delete _impl_.doctype_;
  ------------------
  |  Branch (7539:7): [True: 8.20k, False: 0]
  ------------------
 7540|  8.20k|}
_ZN14xmlProtoFuzzer8KeyValue10SharedCtorEPN6google8protobuf5ArenaEb:
 7789|  34.2k|    ::_pb::Arena* arena, bool is_message_owned) {
 7790|  34.2k|  (void)arena;
 7791|  34.2k|  (void)is_message_owned;
 7792|  34.2k|  new (&_impl_) Impl_{
 7793|  34.2k|      decltype(_impl_.key_){}
 7794|  34.2k|    , decltype(_impl_.value_){}
 7795|  34.2k|    , decltype(_impl_.type_){0}
 7796|  34.2k|    , /*decltype(_impl_._cached_size_)*/{}
 7797|  34.2k|  };
 7798|  34.2k|  _impl_.key_.InitDefault();
 7799|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7800|       |    _impl_.key_.Set("", GetArenaForAllocation());
 7801|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7802|  34.2k|  _impl_.value_.InitDefault();
 7803|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7804|       |    _impl_.value_.Set("", GetArenaForAllocation());
 7805|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 7806|  34.2k|}
_ZN14xmlProtoFuzzer8KeyValue10SharedDtorEv:
 7817|  34.2k|inline void KeyValue::SharedDtor() {
 7818|  34.2k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  34.2k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 7819|  34.2k|  _impl_.key_.Destroy();
 7820|  34.2k|  _impl_.value_.Destroy();
 7821|  34.2k|}
_ZN14xmlProtoFuzzer21ProcessingInstruction10SharedCtorEPN6google8protobuf5ArenaEb:
 8062|  1.51k|    ::_pb::Arena* arena, bool is_message_owned) {
 8063|  1.51k|  (void)arena;
 8064|  1.51k|  (void)is_message_owned;
 8065|  1.51k|  new (&_impl_) Impl_{
 8066|  1.51k|      decltype(_impl_.kv_){arena}
 8067|  1.51k|    , decltype(_impl_.name_){}
 8068|  1.51k|    , /*decltype(_impl_._cached_size_)*/{}
 8069|  1.51k|  };
 8070|  1.51k|  _impl_.name_.InitDefault();
 8071|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8072|       |    _impl_.name_.Set("", GetArenaForAllocation());
 8073|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8074|  1.51k|}
_ZN14xmlProtoFuzzer21ProcessingInstruction10SharedDtorEv:
 8085|  1.51k|inline void ProcessingInstruction::SharedDtor() {
 8086|  1.51k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  1.51k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8087|  1.51k|  _impl_.kv_.~RepeatedPtrField();
 8088|  1.51k|  _impl_.name_.Destroy();
 8089|  1.51k|}
_ZN14xmlProtoFuzzer5CData10SharedCtorEPN6google8protobuf5ArenaEb:
 8298|  3.65k|    ::_pb::Arena* arena, bool is_message_owned) {
 8299|  3.65k|  (void)arena;
 8300|  3.65k|  (void)is_message_owned;
 8301|  3.65k|  new (&_impl_) Impl_{
 8302|  3.65k|      decltype(_impl_.data_){}
 8303|  3.65k|    , /*decltype(_impl_._cached_size_)*/{}
 8304|  3.65k|  };
 8305|  3.65k|  _impl_.data_.InitDefault();
 8306|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8307|       |    _impl_.data_.Set("", GetArenaForAllocation());
 8308|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8309|  3.65k|}
_ZN14xmlProtoFuzzer5CData10SharedDtorEv:
 8320|  3.65k|inline void CData::SharedDtor() {
 8321|  3.65k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  3.65k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8322|  3.65k|  _impl_.data_.Destroy();
 8323|  3.65k|}
_ZN14xmlProtoFuzzer7Content10SharedCtorEPN6google8protobuf5ArenaEb:
 8554|  21.2k|    ::_pb::Arena* arena, bool is_message_owned) {
 8555|  21.2k|  (void)arena;
 8556|  21.2k|  (void)is_message_owned;
 8557|  21.2k|  new (&_impl_) Impl_{
 8558|  21.2k|      decltype(_impl_.content_oneof_){}
 8559|  21.2k|    , /*decltype(_impl_._cached_size_)*/{}
 8560|  21.2k|    , /*decltype(_impl_._oneof_case_)*/{}
 8561|  21.2k|  };
 8562|  21.2k|  clear_has_content_oneof();
 8563|  21.2k|}
_ZN14xmlProtoFuzzer7Content10SharedDtorEv:
 8574|  21.2k|inline void Content::SharedDtor() {
 8575|  21.2k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  21.2k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8576|  21.2k|  if (has_content_oneof()) {
  ------------------
  |  Branch (8576:7): [True: 13.9k, False: 7.28k]
  ------------------
 8577|  13.9k|    clear_content_oneof();
 8578|  13.9k|  }
 8579|  21.2k|}
_ZN14xmlProtoFuzzer7Element10SharedCtorEPN6google8protobuf5ArenaEb:
 8869|   417k|    ::_pb::Arena* arena, bool is_message_owned) {
 8870|   417k|  (void)arena;
 8871|   417k|  (void)is_message_owned;
 8872|   417k|  new (&_impl_) Impl_{
 8873|   417k|      decltype(_impl_.kv_){arena}
 8874|   417k|    , decltype(_impl_.name_){}
 8875|   417k|    , decltype(_impl_.childprop_){}
 8876|   417k|    , decltype(_impl_.content_){nullptr}
 8877|   417k|    , decltype(_impl_.type_){0}
 8878|   417k|    , decltype(_impl_.id_){0}
 8879|   417k|    , /*decltype(_impl_._cached_size_)*/{}
 8880|   417k|  };
 8881|   417k|  _impl_.name_.InitDefault();
 8882|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8883|       |    _impl_.name_.Set("", GetArenaForAllocation());
 8884|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8885|   417k|  _impl_.childprop_.InitDefault();
 8886|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8887|       |    _impl_.childprop_.Set("", GetArenaForAllocation());
 8888|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 8889|   417k|}
_ZN14xmlProtoFuzzer7Element10SharedDtorEv:
 8900|   417k|inline void Element::SharedDtor() {
 8901|   417k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|   417k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 8902|   417k|  _impl_.kv_.~RepeatedPtrField();
 8903|   417k|  _impl_.name_.Destroy();
 8904|   417k|  _impl_.childprop_.Destroy();
 8905|   417k|  if (this != internal_default_instance()) delete _impl_.content_;
  ------------------
  |  Branch (8905:7): [True: 417k, False: 0]
  ------------------
 8906|   417k|}
_ZN14xmlProtoFuzzer10VersionNum10SharedCtorEPN6google8protobuf5ArenaEb:
 9236|    224|    ::_pb::Arena* arena, bool is_message_owned) {
 9237|    224|  (void)arena;
 9238|    224|  (void)is_message_owned;
 9239|    224|  new (&_impl_) Impl_{
 9240|    224|      decltype(_impl_.major_){uint64_t{0u}}
 9241|    224|    , decltype(_impl_.minor_){uint64_t{0u}}
 9242|    224|    , decltype(_impl_.type_){0}
 9243|    224|    , /*decltype(_impl_._cached_size_)*/{}
 9244|    224|  };
 9245|    224|}
_ZN14xmlProtoFuzzer10VersionNum10SharedDtorEv:
 9256|    224|inline void VersionNum::SharedDtor() {
 9257|    224|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|    224|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 9258|    224|}
_ZN14xmlProtoFuzzer9Encodings10SharedCtorEPN6google8protobuf5ArenaEb:
 9479|  1.75k|    ::_pb::Arena* arena, bool is_message_owned) {
 9480|  1.75k|  (void)arena;
 9481|  1.75k|  (void)is_message_owned;
 9482|  1.75k|  new (&_impl_) Impl_{
 9483|  1.75k|      decltype(_impl_.fuzz_){}
 9484|  1.75k|    , decltype(_impl_.name_){0}
 9485|  1.75k|    , /*decltype(_impl_._cached_size_)*/{}
 9486|  1.75k|  };
 9487|  1.75k|  _impl_.fuzz_.InitDefault();
 9488|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 9489|       |    _impl_.fuzz_.Set("", GetArenaForAllocation());
 9490|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 9491|  1.75k|}
_ZN14xmlProtoFuzzer9Encodings10SharedDtorEv:
 9502|  1.75k|inline void Encodings::SharedDtor() {
 9503|  1.75k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  1.75k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 9504|  1.75k|  _impl_.fuzz_.Destroy();
 9505|  1.75k|}
_ZN14xmlProtoFuzzer14XmlDeclaration10SharedCtorEPN6google8protobuf5ArenaEb:
 9730|  2.11k|    ::_pb::Arena* arena, bool is_message_owned) {
 9731|  2.11k|  (void)arena;
 9732|  2.11k|  (void)is_message_owned;
 9733|  2.11k|  new (&_impl_) Impl_{
 9734|  2.11k|      decltype(_impl_.fuzz_){}
 9735|  2.11k|    , decltype(_impl_.ver_){nullptr}
 9736|  2.11k|    , decltype(_impl_.enc_){nullptr}
 9737|  2.11k|    , decltype(_impl_.standalone_){0}
 9738|  2.11k|    , /*decltype(_impl_._cached_size_)*/{}
 9739|  2.11k|  };
 9740|  2.11k|  _impl_.fuzz_.InitDefault();
 9741|       |  #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
 9742|       |    _impl_.fuzz_.Set("", GetArenaForAllocation());
 9743|       |  #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
 9744|  2.11k|}
_ZN14xmlProtoFuzzer14XmlDeclaration10SharedDtorEv:
 9755|  2.11k|inline void XmlDeclaration::SharedDtor() {
 9756|  2.11k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  2.11k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
 9757|  2.11k|  _impl_.fuzz_.Destroy();
 9758|  2.11k|  if (this != internal_default_instance()) delete _impl_.ver_;
  ------------------
  |  Branch (9758:7): [True: 2.11k, False: 0]
  ------------------
 9759|  2.11k|  if (this != internal_default_instance()) delete _impl_.enc_;
  ------------------
  |  Branch (9759:7): [True: 2.11k, False: 0]
  ------------------
 9760|  2.11k|}
_ZN14xmlProtoFuzzer11XmlDocument10SharedCtorEPN6google8protobuf5ArenaEb:
10031|  8.78k|    ::_pb::Arena* arena, bool is_message_owned) {
10032|  8.78k|  (void)arena;
10033|  8.78k|  (void)is_message_owned;
10034|  8.78k|  new (&_impl_) Impl_{
10035|  8.78k|      decltype(_impl_.e_){arena}
10036|  8.78k|    , decltype(_impl_.p_){nullptr}
10037|  8.78k|    , /*decltype(_impl_._cached_size_)*/{}
10038|  8.78k|  };
10039|  8.78k|}
_ZN14xmlProtoFuzzer11XmlDocument10SharedDtorEv:
10050|  8.78k|inline void XmlDocument::SharedDtor() {
10051|  8.78k|  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  ------------------
  |  |  179|  8.78k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  152|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  149|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  145|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  146|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  147|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (149:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (179:41): [Folded - Ignored]
  |  |  ------------------
  ------------------
10052|  8.78k|  _impl_.e_.~RepeatedPtrField();
10053|  8.78k|  if (this != internal_default_instance()) delete _impl_.p_;
  ------------------
  |  Branch (10053:7): [True: 8.78k, False: 0]
  ------------------
10054|  8.78k|}

_ZN14xmlProtoFuzzer4Misc5Impl_14MiscOneofUnionC2Ev:
  802|  4.89k|      constexpr MiscOneofUnion() : _constinit_{} {}
_ZN14xmlProtoFuzzer4Misc20clear_has_misc_oneofEv:
 7365|  4.89k|inline void Misc::clear_has_misc_oneof() {
 7366|  4.89k|  _impl_._oneof_case_[0] = MISC_ONEOF_NOT_SET;
 7367|  4.89k|}
_ZNK14xmlProtoFuzzer4Misc15misc_oneof_caseEv:
 7368|  15.8k|inline Misc::MiscOneofCase Misc::misc_oneof_case() const {
 7369|  15.8k|  return Misc::MiscOneofCase(_impl_._oneof_case_[0]);
 7370|  15.8k|}
_ZNK14xmlProtoFuzzer4Misc17_internal_commentEv:
 7246|  1.72k|inline const std::string& Misc::_internal_comment() const {
 7247|  1.72k|  if (_internal_has_comment()) {
  ------------------
  |  Branch (7247:7): [True: 1.72k, False: 0]
  ------------------
 7248|  1.72k|    return _impl_.misc_oneof_.comment_.Get();
 7249|  1.72k|  }
 7250|      0|  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 7251|  1.72k|}
_ZNK14xmlProtoFuzzer4Misc14_internal_instEv:
 7320|  1.37k|inline const ::xmlProtoFuzzer::ProcessingInstruction& Misc::_internal_inst() const {
 7321|  1.37k|  return _internal_has_inst()
  ------------------
  |  Branch (7321:10): [True: 1.37k, False: 0]
  ------------------
 7322|  1.37k|      ? *_impl_.misc_oneof_.inst_
 7323|  1.37k|      : reinterpret_cast< ::xmlProtoFuzzer::ProcessingInstruction&>(::xmlProtoFuzzer::_ProcessingInstruction_default_instance_);
 7324|  1.37k|}
_ZNK14xmlProtoFuzzer4Misc14has_misc_oneofEv:
 7362|  4.89k|inline bool Misc::has_misc_oneof() const {
 7363|  4.89k|  return misc_oneof_case() != MISC_ONEOF_NOT_SET;
 7364|  4.89k|}
_ZNK14xmlProtoFuzzer4Misc21_internal_has_commentEv:
 7212|  1.72k|inline bool Misc::_internal_has_comment() const {
 7213|  1.72k|  return misc_oneof_case() == kComment;
 7214|  1.72k|}
_ZNK14xmlProtoFuzzer4Misc18_internal_has_instEv:
 7289|  1.37k|inline bool Misc::_internal_has_inst() const {
 7290|  1.37k|  return misc_oneof_case() == kInst;
 7291|  1.37k|}
_ZNK14xmlProtoFuzzer11ElementDecl14_internal_nameEv:
 7449|  5.66k|inline const std::string& ElementDecl::_internal_name() const {
 7450|  5.66k|  return _impl_.name_.Get();
 7451|  5.66k|}
_ZNK14xmlProtoFuzzer11ElementDecl14_internal_specEv:
 7483|  11.3k|inline ::xmlProtoFuzzer::ElementDecl_ContentSpec ElementDecl::_internal_spec() const {
 7484|  11.3k|  return static_cast< ::xmlProtoFuzzer::ElementDecl_ContentSpec >(_impl_.spec_);
 7485|  11.3k|}
_ZNK14xmlProtoFuzzer11ElementDecl20_internal_cdata_sizeEv:
 7500|  1.11k|inline int ElementDecl::_internal_cdata_size() const {
 7501|  1.11k|  return _impl_.cdata_.size();
 7502|  1.11k|}
_ZNK14xmlProtoFuzzer10ExternalId16_internal_systemEv:
 8045|  17.2k|inline const std::string& ExternalId::_internal_system() const {
 8046|  17.2k|  return _impl_.system_.Get();
 8047|  17.2k|}
_ZNK14xmlProtoFuzzer10ExternalId13_internal_pubEv:
 8095|  6.98k|inline const std::string& ExternalId::_internal_pub() const {
 8096|  6.98k|  return _impl_.pub_.Get();
 8097|  6.98k|}
_ZNK14xmlProtoFuzzer10ExternalId14_internal_typeEv:
 8009|  33.3k|inline ::xmlProtoFuzzer::ExternalId_Type ExternalId::_internal_type() const {
 8010|  33.3k|  return static_cast< ::xmlProtoFuzzer::ExternalId_Type >(_impl_.type_);
 8011|  33.3k|}
_ZNK14xmlProtoFuzzer8AttValue14_internal_typeEv:
 8133|  8.10k|inline ::xmlProtoFuzzer::AttValue_Type AttValue::_internal_type() const {
 8134|  8.10k|  return static_cast< ::xmlProtoFuzzer::AttValue_Type >(_impl_.type_);
 8135|  8.10k|}
_ZN14xmlProtoFuzzer11DefaultDecl25internal_default_instanceEv:
 2222|  4.58k|  static inline const DefaultDecl* internal_default_instance() {
 2223|  4.58k|    return reinterpret_cast<const DefaultDecl*>(
 2224|  4.58k|               &_DefaultDecl_default_instance_);
 2225|  4.58k|  }
_ZNK14xmlProtoFuzzer11DefaultDecl14_internal_typeEv:
 8232|  37.3k|inline ::xmlProtoFuzzer::DefaultDecl_Type DefaultDecl::_internal_type() const {
 8233|  37.3k|  return static_cast< ::xmlProtoFuzzer::DefaultDecl_Type >(_impl_.type_);
 8234|  37.3k|}
_ZNK14xmlProtoFuzzer11DefaultDecl13_internal_attEv:
 8261|  3.16k|inline const ::xmlProtoFuzzer::AttValue& DefaultDecl::_internal_att() const {
 8262|  3.16k|  const ::xmlProtoFuzzer::AttValue* p = _impl_.att_;
 8263|  3.16k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::AttValue&>(
  ------------------
  |  Branch (8263:10): [True: 2.30k, False: 860]
  ------------------
 8264|    860|      ::xmlProtoFuzzer::_AttValue_default_instance_);
 8265|  3.16k|}
_ZNK14xmlProtoFuzzer6AttDef14_internal_nameEv:
 8362|  18.7k|inline const std::string& AttDef::_internal_name() const {
 8363|  18.7k|  return _impl_.name_.Get();
 8364|  18.7k|}
_ZN14xmlProtoFuzzer6AttDef25internal_default_instanceEv:
 2424|  19.2k|  static inline const AttDef* internal_default_instance() {
 2425|  19.2k|    return reinterpret_cast<const AttDef*>(
 2426|  19.2k|               &_AttDef_default_instance_);
 2427|  19.2k|  }
_ZNK14xmlProtoFuzzer6AttDef14_internal_typeEv:
 8396|  37.6k|inline ::xmlProtoFuzzer::AttDef_Type AttDef::_internal_type() const {
 8397|  37.6k|  return static_cast< ::xmlProtoFuzzer::AttDef_Type >(_impl_.type_);
 8398|  37.6k|}
_ZNK14xmlProtoFuzzer6AttDef13_internal_defEv:
 8425|  18.7k|inline const ::xmlProtoFuzzer::DefaultDecl& AttDef::_internal_def() const {
 8426|  18.7k|  const ::xmlProtoFuzzer::DefaultDecl* p = _impl_.def_;
 8427|  18.7k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::DefaultDecl&>(
  ------------------
  |  Branch (8427:10): [True: 4.42k, False: 14.3k]
  ------------------
 8428|  14.3k|      ::xmlProtoFuzzer::_DefaultDecl_default_instance_);
 8429|  18.7k|}
_ZNK14xmlProtoFuzzer11AttListDecl14_internal_nameEv:
 8526|  3.81k|inline const std::string& AttListDecl::_internal_name() const {
 8527|  3.81k|  return _impl_.name_.Get();
 8528|  3.81k|}
_ZN14xmlProtoFuzzer12NotationDecl5Impl_18NotationOneofUnionC2Ev:
 3001|  5.63k|      constexpr NotationOneofUnion() : _constinit_{} {}
_ZNK14xmlProtoFuzzer12NotationDecl14_internal_nameEv:
 8620|  5.15k|inline const std::string& NotationDecl::_internal_name() const {
 8621|  5.15k|  return _impl_.name_.Get();
 8622|  5.15k|}
_ZN14xmlProtoFuzzer12NotationDecl24clear_has_notation_oneofEv:
 8881|  5.63k|inline void NotationDecl::clear_has_notation_oneof() {
 8882|  5.63k|  _impl_._oneof_case_[0] = NOTATION_ONEOF_NOT_SET;
 8883|  5.63k|}
_ZNK14xmlProtoFuzzer12NotationDecl19notation_oneof_caseEv:
 8884|  19.7k|inline NotationDecl::NotationOneofCase NotationDecl::notation_oneof_case() const {
 8885|  19.7k|  return NotationDecl::NotationOneofCase(_impl_._oneof_case_[0]);
 8886|  19.7k|}
_ZNK14xmlProtoFuzzer12NotationDecl13_internal_extEv:
 8682|  1.05k|inline const ::xmlProtoFuzzer::ExternalId& NotationDecl::_internal_ext() const {
 8683|  1.05k|  return _internal_has_ext()
  ------------------
  |  Branch (8683:10): [True: 1.05k, False: 0]
  ------------------
 8684|  1.05k|      ? *_impl_.notation_oneof_.ext_
 8685|  1.05k|      : reinterpret_cast< ::xmlProtoFuzzer::ExternalId&>(::xmlProtoFuzzer::_ExternalId_default_instance_);
 8686|  1.05k|}
_ZNK14xmlProtoFuzzer12NotationDecl13_internal_pubEv:
 8759|  2.72k|inline const std::string& NotationDecl::_internal_pub() const {
 8760|  2.72k|  if (_internal_has_pub()) {
  ------------------
  |  Branch (8760:7): [True: 2.72k, False: 0]
  ------------------
 8761|  2.72k|    return _impl_.notation_oneof_.pub_.Get();
 8762|  2.72k|  }
 8763|      0|  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 8764|  2.72k|}
_ZNK14xmlProtoFuzzer12NotationDecl14_internal_fuzzEv:
 8836|    661|inline const std::string& NotationDecl::_internal_fuzz() const {
 8837|    661|  if (_internal_has_fuzz()) {
  ------------------
  |  Branch (8837:7): [True: 661, False: 0]
  ------------------
 8838|    661|    return _impl_.notation_oneof_.fuzz_.Get();
 8839|    661|  }
 8840|      0|  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
 8841|    661|}
_ZNK14xmlProtoFuzzer12NotationDecl18has_notation_oneofEv:
 8878|  5.63k|inline bool NotationDecl::has_notation_oneof() const {
 8879|  5.63k|  return notation_oneof_case() != NOTATION_ONEOF_NOT_SET;
 8880|  5.63k|}
_ZNK14xmlProtoFuzzer12NotationDecl17_internal_has_extEv:
 8651|  1.05k|inline bool NotationDecl::_internal_has_ext() const {
 8652|  1.05k|  return notation_oneof_case() == kExt;
 8653|  1.05k|}
_ZNK14xmlProtoFuzzer12NotationDecl17_internal_has_pubEv:
 8725|  2.72k|inline bool NotationDecl::_internal_has_pub() const {
 8726|  2.72k|  return notation_oneof_case() == kPub;
 8727|  2.72k|}
_ZNK14xmlProtoFuzzer12NotationDecl18_internal_has_fuzzEv:
 8802|    661|inline bool NotationDecl::_internal_has_fuzz() const {
 8803|    661|  return notation_oneof_case() == kFuzz;
 8804|    661|}
_ZNK14xmlProtoFuzzer11EntityValue14_internal_typeEv:
 8895|  11.8k|inline ::xmlProtoFuzzer::EntityValue_Type EntityValue::_internal_type() const {
 8896|  11.8k|  return static_cast< ::xmlProtoFuzzer::EntityValue_Type >(_impl_.type_);
 8897|  11.8k|}
_ZNK14xmlProtoFuzzer9NDataDecl14_internal_nameEv:
 9010|  4.06k|inline const std::string& NDataDecl::_internal_name() const {
 9011|  4.06k|  return _impl_.name_.Get();
 9012|  4.06k|}
_ZN14xmlProtoFuzzer9EntityDef5Impl_16EntityOneofUnionC2Ev:
 3579|  7.68k|      constexpr EntityOneofUnion() : _constinit_{} {}
_ZNK14xmlProtoFuzzer9EntityDef19_internal_has_ndataEv:
 9193|  4.11k|inline bool EntityDef::_internal_has_ndata() const {
 9194|  4.11k|  return this != internal_default_instance() && _impl_.ndata_ != nullptr;
  ------------------
  |  Branch (9194:10): [True: 4.11k, False: 0]
  |  Branch (9194:49): [True: 1.44k, False: 2.67k]
  ------------------
 9195|  4.11k|}
_ZN14xmlProtoFuzzer9EntityDef25internal_default_instanceEv:
 3426|  11.8k|  static inline const EntityDef* internal_default_instance() {
 3427|  11.8k|    return reinterpret_cast<const EntityDef*>(
 3428|  11.8k|               &_EntityDef_default_instance_);
 3429|  11.8k|  }
_ZN14xmlProtoFuzzer9EntityDef22clear_has_entity_oneofEv:
 9285|  7.68k|inline void EntityDef::clear_has_entity_oneof() {
 9286|  7.68k|  _impl_._oneof_case_[0] = ENTITY_ONEOF_NOT_SET;
 9287|  7.68k|}
_ZNK14xmlProtoFuzzer9EntityDef17entity_oneof_caseEv:
 9288|  34.8k|inline EntityDef::EntityOneofCase EntityDef::entity_oneof_case() const {
 9289|  34.8k|  return EntityDef::EntityOneofCase(_impl_._oneof_case_[0]);
 9290|  34.8k|}
_ZNK14xmlProtoFuzzer9EntityDef13_internal_extEv:
 9076|  4.11k|inline const ::xmlProtoFuzzer::ExternalId& EntityDef::_internal_ext() const {
 9077|  4.11k|  return _internal_has_ext()
  ------------------
  |  Branch (9077:10): [True: 4.11k, False: 0]
  ------------------
 9078|  4.11k|      ? *_impl_.entity_oneof_.ext_
 9079|  4.11k|      : reinterpret_cast< ::xmlProtoFuzzer::ExternalId&>(::xmlProtoFuzzer::_ExternalId_default_instance_);
 9080|  4.11k|}
_ZNK14xmlProtoFuzzer9EntityDef13_internal_valEv:
 9150|  2.82k|inline const ::xmlProtoFuzzer::EntityValue& EntityDef::_internal_val() const {
 9151|  2.82k|  return _internal_has_val()
  ------------------
  |  Branch (9151:10): [True: 2.82k, False: 0]
  ------------------
 9152|  2.82k|      ? *_impl_.entity_oneof_.val_
 9153|  2.82k|      : reinterpret_cast< ::xmlProtoFuzzer::EntityValue&>(::xmlProtoFuzzer::_EntityValue_default_instance_);
 9154|  2.82k|}
_ZNK14xmlProtoFuzzer9EntityDef16has_entity_oneofEv:
 9282|  7.68k|inline bool EntityDef::has_entity_oneof() const {
 9283|  7.68k|  return entity_oneof_case() != ENTITY_ONEOF_NOT_SET;
 9284|  7.68k|}
_ZNK14xmlProtoFuzzer9EntityDef17_internal_has_extEv:
 9045|  4.11k|inline bool EntityDef::_internal_has_ext() const {
 9046|  4.11k|  return entity_oneof_case() == kExt;
 9047|  4.11k|}
_ZNK14xmlProtoFuzzer9EntityDef17_internal_has_valEv:
 9119|  2.82k|inline bool EntityDef::_internal_has_val() const {
 9120|  2.82k|  return entity_oneof_case() == kVal;
 9121|  2.82k|}
_ZNK14xmlProtoFuzzer9EntityDef15_internal_ndataEv:
 9205|  1.75k|inline const ::xmlProtoFuzzer::NDataDecl& EntityDef::_internal_ndata() const {
 9206|  1.75k|  const ::xmlProtoFuzzer::NDataDecl* p = _impl_.ndata_;
 9207|  1.75k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::NDataDecl&>(
  ------------------
  |  Branch (9207:10): [True: 870, False: 889]
  ------------------
 9208|    889|      ::xmlProtoFuzzer::_NDataDecl_default_instance_);
 9209|  1.75k|}
_ZN14xmlProtoFuzzer5PEDef5Impl_15PedefOneofUnionC2Ev:
 3775|  3.42k|      constexpr PedefOneofUnion() : _constinit_{} {}
_ZN14xmlProtoFuzzer5PEDef21clear_has_pedef_oneofEv:
 9446|  3.42k|inline void PEDef::clear_has_pedef_oneof() {
 9447|  3.42k|  _impl_._oneof_case_[0] = PEDEF_ONEOF_NOT_SET;
 9448|  3.42k|}
_ZNK14xmlProtoFuzzer5PEDef16pedef_oneof_caseEv:
 9449|  11.4k|inline PEDef::PedefOneofCase PEDef::pedef_oneof_case() const {
 9450|  11.4k|  return PEDef::PedefOneofCase(_impl_._oneof_case_[0]);
 9451|  11.4k|}
_ZNK14xmlProtoFuzzer5PEDef13_internal_valEv:
 9327|  1.37k|inline const ::xmlProtoFuzzer::EntityValue& PEDef::_internal_val() const {
 9328|  1.37k|  return _internal_has_val()
  ------------------
  |  Branch (9328:10): [True: 1.37k, False: 0]
  ------------------
 9329|  1.37k|      ? *_impl_.pedef_oneof_.val_
 9330|  1.37k|      : reinterpret_cast< ::xmlProtoFuzzer::EntityValue&>(::xmlProtoFuzzer::_EntityValue_default_instance_);
 9331|  1.37k|}
_ZNK14xmlProtoFuzzer5PEDef12_internal_idEv:
 9401|    837|inline const ::xmlProtoFuzzer::ExternalId& PEDef::_internal_id() const {
 9402|    837|  return _internal_has_id()
  ------------------
  |  Branch (9402:10): [True: 837, False: 0]
  ------------------
 9403|    837|      ? *_impl_.pedef_oneof_.id_
 9404|    837|      : reinterpret_cast< ::xmlProtoFuzzer::ExternalId&>(::xmlProtoFuzzer::_ExternalId_default_instance_);
 9405|    837|}
_ZNK14xmlProtoFuzzer5PEDef15has_pedef_oneofEv:
 9443|  3.42k|inline bool PEDef::has_pedef_oneof() const {
 9444|  3.42k|  return pedef_oneof_case() != PEDEF_ONEOF_NOT_SET;
 9445|  3.42k|}
_ZNK14xmlProtoFuzzer5PEDef17_internal_has_valEv:
 9296|  1.37k|inline bool PEDef::_internal_has_val() const {
 9297|  1.37k|  return pedef_oneof_case() == kVal;
 9298|  1.37k|}
_ZNK14xmlProtoFuzzer5PEDef16_internal_has_idEv:
 9370|    837|inline bool PEDef::_internal_has_id() const {
 9371|    837|  return pedef_oneof_case() == kId;
 9372|    837|}
_ZNK14xmlProtoFuzzer10EntityDecl14_internal_nameEv:
 9496|  12.3k|inline const std::string& EntityDecl::_internal_name() const {
 9497|  12.3k|  return _impl_.name_.Get();
 9498|  12.3k|}
_ZN14xmlProtoFuzzer10EntityDecl25internal_default_instanceEv:
 3832|  26.1k|  static inline const EntityDecl* internal_default_instance() {
 3833|  26.1k|    return reinterpret_cast<const EntityDecl*>(
 3834|  26.1k|               &_EntityDecl_default_instance_);
 3835|  26.1k|  }
_ZNK14xmlProtoFuzzer10EntityDecl14_internal_typeEv:
 9460|  24.8k|inline ::xmlProtoFuzzer::EntityDecl_Type EntityDecl::_internal_type() const {
 9461|  24.8k|  return static_cast< ::xmlProtoFuzzer::EntityDecl_Type >(_impl_.type_);
 9462|  24.8k|}
_ZNK14xmlProtoFuzzer10EntityDecl13_internal_entEv:
 9539|  8.98k|inline const ::xmlProtoFuzzer::EntityDef& EntityDecl::_internal_ent() const {
 9540|  8.98k|  const ::xmlProtoFuzzer::EntityDef* p = _impl_.ent_;
 9541|  8.98k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::EntityDef&>(
  ------------------
  |  Branch (9541:10): [True: 7.22k, False: 1.76k]
  ------------------
 9542|  1.76k|      ::xmlProtoFuzzer::_EntityDef_default_instance_);
 9543|  8.98k|}
_ZNK14xmlProtoFuzzer10EntityDecl15_internal_pedefEv:
 9629|  3.36k|inline const ::xmlProtoFuzzer::PEDef& EntityDecl::_internal_pedef() const {
 9630|  3.36k|  const ::xmlProtoFuzzer::PEDef* p = _impl_.pedef_;
 9631|  3.36k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::PEDef&>(
  ------------------
  |  Branch (9631:10): [True: 2.49k, False: 873]
  ------------------
 9632|    873|      ::xmlProtoFuzzer::_PEDef_default_instance_);
 9633|  3.36k|}
_ZN14xmlProtoFuzzer15ConditionalSect25internal_default_instanceEv:
 4066|  7.30k|  static inline const ConditionalSect* internal_default_instance() {
 4067|  7.30k|    return reinterpret_cast<const ConditionalSect*>(
 4068|  7.30k|               &_ConditionalSect_default_instance_);
 4069|  7.30k|  }
_ZNK14xmlProtoFuzzer15ConditionalSect14_internal_typeEv:
 9714|  13.9k|inline ::xmlProtoFuzzer::ConditionalSect_Type ConditionalSect::_internal_type() const {
 9715|  13.9k|  return static_cast< ::xmlProtoFuzzer::ConditionalSect_Type >(_impl_.type_);
 9716|  13.9k|}
_ZNK14xmlProtoFuzzer15ConditionalSect13_internal_extEv:
 9743|  5.96k|inline const ::xmlProtoFuzzer::ExtSubsetDecl& ConditionalSect::_internal_ext() const {
 9744|  5.96k|  const ::xmlProtoFuzzer::ExtSubsetDecl* p = _impl_.ext_;
 9745|  5.96k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::ExtSubsetDecl&>(
  ------------------
  |  Branch (9745:10): [True: 3.57k, False: 2.39k]
  ------------------
 9746|  2.39k|      ::xmlProtoFuzzer::_ExtSubsetDecl_default_instance_);
 9747|  5.96k|}
_ZN14xmlProtoFuzzer16OneExtSubsetDecl5Impl_19ExtsubsetOneofUnionC2Ev:
 4431|  34.5k|      constexpr ExtsubsetOneofUnion() : _constinit_{} {}
_ZN14xmlProtoFuzzer16OneExtSubsetDecl25clear_has_extsubset_oneofEv:
10050|  34.5k|inline void OneExtSubsetDecl::clear_has_extsubset_oneof() {
10051|  34.5k|  _impl_._oneof_case_[0] = EXTSUBSET_ONEOF_NOT_SET;
10052|  34.5k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl20extsubset_oneof_caseEv:
10053|   121k|inline OneExtSubsetDecl::ExtsubsetOneofCase OneExtSubsetDecl::extsubset_oneof_case() const {
10054|   121k|  return OneExtSubsetDecl::ExtsubsetOneofCase(_impl_._oneof_case_[0]);
10055|   121k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl11_internal_mEv:
 9931|  19.1k|inline const ::xmlProtoFuzzer::MarkupDecl& OneExtSubsetDecl::_internal_m() const {
 9932|  19.1k|  return _internal_has_m()
  ------------------
  |  Branch (9932:10): [True: 19.1k, False: 0]
  ------------------
 9933|  19.1k|      ? *_impl_.extsubset_oneof_.m_
 9934|  19.1k|      : reinterpret_cast< ::xmlProtoFuzzer::MarkupDecl&>(::xmlProtoFuzzer::_MarkupDecl_default_instance_);
 9935|  19.1k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl11_internal_cEv:
10005|  7.06k|inline const ::xmlProtoFuzzer::ConditionalSect& OneExtSubsetDecl::_internal_c() const {
10006|  7.06k|  return _internal_has_c()
  ------------------
  |  Branch (10006:10): [True: 7.06k, False: 0]
  ------------------
10007|  7.06k|      ? *_impl_.extsubset_oneof_.c_
10008|  7.06k|      : reinterpret_cast< ::xmlProtoFuzzer::ConditionalSect&>(::xmlProtoFuzzer::_ConditionalSect_default_instance_);
10009|  7.06k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl19has_extsubset_oneofEv:
10047|  34.5k|inline bool OneExtSubsetDecl::has_extsubset_oneof() const {
10048|  34.5k|  return extsubset_oneof_case() != EXTSUBSET_ONEOF_NOT_SET;
10049|  34.5k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl15_internal_has_mEv:
 9900|  19.1k|inline bool OneExtSubsetDecl::_internal_has_m() const {
 9901|  19.1k|  return extsubset_oneof_case() == kM;
 9902|  19.1k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl15_internal_has_cEv:
 9974|  7.06k|inline bool OneExtSubsetDecl::_internal_has_c() const {
 9975|  7.06k|  return extsubset_oneof_case() == kC;
 9976|  7.06k|}
_ZN14xmlProtoFuzzer10MarkupDecl5Impl_16MarkupOneofUnionC2Ev:
 4868|  42.0k|      constexpr MarkupOneofUnion() : _constinit_{} {}
_ZN14xmlProtoFuzzer10MarkupDecl22clear_has_markup_oneofEv:
10551|  42.0k|inline void MarkupDecl::clear_has_markup_oneof() {
10552|  42.0k|  _impl_._oneof_case_[0] = MARKUP_ONEOF_NOT_SET;
10553|  42.0k|}
_ZNK14xmlProtoFuzzer10MarkupDecl17markup_oneof_caseEv:
10554|   151k|inline MarkupDecl::MarkupOneofCase MarkupDecl::markup_oneof_case() const {
10555|   151k|  return MarkupDecl::MarkupOneofCase(_impl_._oneof_case_[0]);
10556|   151k|}
_ZNK14xmlProtoFuzzer10MarkupDecl11_internal_eEv:
10136|  5.70k|inline const ::xmlProtoFuzzer::ElementDecl& MarkupDecl::_internal_e() const {
10137|  5.70k|  return _internal_has_e()
  ------------------
  |  Branch (10137:10): [True: 5.70k, False: 0]
  ------------------
10138|  5.70k|      ? *_impl_.markup_oneof_.e_
10139|  5.70k|      : reinterpret_cast< ::xmlProtoFuzzer::ElementDecl&>(::xmlProtoFuzzer::_ElementDecl_default_instance_);
10140|  5.70k|}
_ZNK14xmlProtoFuzzer10MarkupDecl11_internal_aEv:
10210|  3.81k|inline const ::xmlProtoFuzzer::AttListDecl& MarkupDecl::_internal_a() const {
10211|  3.81k|  return _internal_has_a()
  ------------------
  |  Branch (10211:10): [True: 3.81k, False: 0]
  ------------------
10212|  3.81k|      ? *_impl_.markup_oneof_.a_
10213|  3.81k|      : reinterpret_cast< ::xmlProtoFuzzer::AttListDecl&>(::xmlProtoFuzzer::_AttListDecl_default_instance_);
10214|  3.81k|}
_ZNK14xmlProtoFuzzer10MarkupDecl11_internal_nEv:
10284|  5.15k|inline const ::xmlProtoFuzzer::NotationDecl& MarkupDecl::_internal_n() const {
10285|  5.15k|  return _internal_has_n()
  ------------------
  |  Branch (10285:10): [True: 5.15k, False: 0]
  ------------------
10286|  5.15k|      ? *_impl_.markup_oneof_.n_
10287|  5.15k|      : reinterpret_cast< ::xmlProtoFuzzer::NotationDecl&>(::xmlProtoFuzzer::_NotationDecl_default_instance_);
10288|  5.15k|}
_ZNK14xmlProtoFuzzer10MarkupDecl11_internal_mEv:
10358|  1.91k|inline const ::xmlProtoFuzzer::Misc& MarkupDecl::_internal_m() const {
10359|  1.91k|  return _internal_has_m()
  ------------------
  |  Branch (10359:10): [True: 1.91k, False: 0]
  ------------------
10360|  1.91k|      ? *_impl_.markup_oneof_.m_
10361|  1.91k|      : reinterpret_cast< ::xmlProtoFuzzer::Misc&>(::xmlProtoFuzzer::_Misc_default_instance_);
10362|  1.91k|}
_ZNK14xmlProtoFuzzer10MarkupDecl16_internal_entityEv:
10432|  12.4k|inline const ::xmlProtoFuzzer::EntityDecl& MarkupDecl::_internal_entity() const {
10433|  12.4k|  return _internal_has_entity()
  ------------------
  |  Branch (10433:10): [True: 12.4k, False: 0]
  ------------------
10434|  12.4k|      ? *_impl_.markup_oneof_.entity_
10435|  12.4k|      : reinterpret_cast< ::xmlProtoFuzzer::EntityDecl&>(::xmlProtoFuzzer::_EntityDecl_default_instance_);
10436|  12.4k|}
_ZNK14xmlProtoFuzzer10MarkupDecl13_internal_extEv:
10506|  5.03k|inline const ::xmlProtoFuzzer::ExtSubsetDecl& MarkupDecl::_internal_ext() const {
10507|  5.03k|  return _internal_has_ext()
  ------------------
  |  Branch (10507:10): [True: 5.03k, False: 0]
  ------------------
10508|  5.03k|      ? *_impl_.markup_oneof_.ext_
10509|  5.03k|      : reinterpret_cast< ::xmlProtoFuzzer::ExtSubsetDecl&>(::xmlProtoFuzzer::_ExtSubsetDecl_default_instance_);
10510|  5.03k|}
_ZNK14xmlProtoFuzzer10MarkupDecl16has_markup_oneofEv:
10548|  42.0k|inline bool MarkupDecl::has_markup_oneof() const {
10549|  42.0k|  return markup_oneof_case() != MARKUP_ONEOF_NOT_SET;
10550|  42.0k|}
_ZNK14xmlProtoFuzzer10MarkupDecl15_internal_has_eEv:
10105|  5.70k|inline bool MarkupDecl::_internal_has_e() const {
10106|  5.70k|  return markup_oneof_case() == kE;
10107|  5.70k|}
_ZNK14xmlProtoFuzzer10MarkupDecl15_internal_has_aEv:
10179|  3.81k|inline bool MarkupDecl::_internal_has_a() const {
10180|  3.81k|  return markup_oneof_case() == kA;
10181|  3.81k|}
_ZNK14xmlProtoFuzzer10MarkupDecl15_internal_has_nEv:
10253|  5.15k|inline bool MarkupDecl::_internal_has_n() const {
10254|  5.15k|  return markup_oneof_case() == kN;
10255|  5.15k|}
_ZNK14xmlProtoFuzzer10MarkupDecl15_internal_has_mEv:
10327|  1.91k|inline bool MarkupDecl::_internal_has_m() const {
10328|  1.91k|  return markup_oneof_case() == kM;
10329|  1.91k|}
_ZNK14xmlProtoFuzzer10MarkupDecl20_internal_has_entityEv:
10401|  12.4k|inline bool MarkupDecl::_internal_has_entity() const {
10402|  12.4k|  return markup_oneof_case() == kEntity;
10403|  12.4k|}
_ZNK14xmlProtoFuzzer10MarkupDecl17_internal_has_extEv:
10475|  5.03k|inline bool MarkupDecl::_internal_has_ext() const {
10476|  5.03k|  return markup_oneof_case() == kExt;
10477|  5.03k|}
_ZNK14xmlProtoFuzzer11DocTypeDecl14_internal_nameEv:
10581|  8.51k|inline const std::string& DocTypeDecl::_internal_name() const {
10582|  8.51k|  return _impl_.name_.Get();
10583|  8.51k|}
_ZN14xmlProtoFuzzer11DocTypeDecl25internal_default_instanceEv:
 4929|  7.75k|  static inline const DocTypeDecl* internal_default_instance() {
 4930|  7.75k|    return reinterpret_cast<const DocTypeDecl*>(
 4931|  7.75k|               &_DocTypeDecl_default_instance_);
 4932|  7.75k|  }
_ZNK14xmlProtoFuzzer11DocTypeDecl13_internal_extEv:
10624|  8.51k|inline const ::xmlProtoFuzzer::ExternalId& DocTypeDecl::_internal_ext() const {
10625|  8.51k|  const ::xmlProtoFuzzer::ExternalId* p = _impl_.ext_;
10626|  8.51k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::ExternalId&>(
  ------------------
  |  Branch (10626:10): [True: 959, False: 7.55k]
  ------------------
10627|  7.55k|      ::xmlProtoFuzzer::_ExternalId_default_instance_);
10628|  8.51k|}
_ZN14xmlProtoFuzzer6Prolog25internal_default_instanceEv:
 5122|  16.4k|  static inline const Prolog* internal_default_instance() {
 5123|  16.4k|    return reinterpret_cast<const Prolog*>(
 5124|  16.4k|               &_Prolog_default_instance_);
 5125|  16.4k|  }
_ZNK14xmlProtoFuzzer6Prolog14_internal_declEv:
10758|  8.51k|inline const ::xmlProtoFuzzer::XmlDeclaration& Prolog::_internal_decl() const {
10759|  8.51k|  const ::xmlProtoFuzzer::XmlDeclaration* p = _impl_.decl_;
10760|  8.51k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::XmlDeclaration&>(
  ------------------
  |  Branch (10760:10): [True: 2.09k, False: 6.42k]
  ------------------
10761|  6.42k|      ::xmlProtoFuzzer::_XmlDeclaration_default_instance_);
10762|  8.51k|}
_ZNK14xmlProtoFuzzer6Prolog17_internal_doctypeEv:
10848|  8.51k|inline const ::xmlProtoFuzzer::DocTypeDecl& Prolog::_internal_doctype() const {
10849|  8.51k|  const ::xmlProtoFuzzer::DocTypeDecl* p = _impl_.doctype_;
10850|  8.51k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::DocTypeDecl&>(
  ------------------
  |  Branch (10850:10): [True: 7.58k, False: 936]
  ------------------
10851|    936|      ::xmlProtoFuzzer::_DocTypeDecl_default_instance_);
10852|  8.51k|}
_ZNK14xmlProtoFuzzer8KeyValue13_internal_keyEv:
11009|  30.1k|inline const std::string& KeyValue::_internal_key() const {
11010|  30.1k|  return _impl_.key_.Get();
11011|  30.1k|}
_ZNK14xmlProtoFuzzer8KeyValue15_internal_valueEv:
11059|  49.3k|inline const std::string& KeyValue::_internal_value() const {
11060|  49.3k|  return _impl_.value_.Get();
11061|  49.3k|}
_ZNK14xmlProtoFuzzer8KeyValue14_internal_typeEv:
10973|  84.6k|inline ::xmlProtoFuzzer::KeyValue_XmlNamespace KeyValue::_internal_type() const {
10974|  84.6k|  return static_cast< ::xmlProtoFuzzer::KeyValue_XmlNamespace >(_impl_.type_);
10975|  84.6k|}
_ZNK14xmlProtoFuzzer21ProcessingInstruction14_internal_nameEv:
11113|  1.37k|inline const std::string& ProcessingInstruction::_internal_name() const {
11114|  1.37k|  return _impl_.name_.Get();
11115|  1.37k|}
_ZNK14xmlProtoFuzzer5CData14_internal_dataEv:
11207|  3.27k|inline const std::string& CData::_internal_data() const {
11208|  3.27k|  return _impl_.data_.Get();
11209|  3.27k|}
_ZN14xmlProtoFuzzer7Content5Impl_17ContentOneofUnionC2Ev:
 6031|  21.2k|      constexpr ContentOneofUnion() : _constinit_{} {}
_ZN14xmlProtoFuzzer7Content23clear_has_content_oneofEv:
11469|  21.2k|inline void Content::clear_has_content_oneof() {
11470|  21.2k|  _impl_._oneof_case_[0] = CONTENT_ONEOF_NOT_SET;
11471|  21.2k|}
_ZNK14xmlProtoFuzzer7Content18content_oneof_caseEv:
11472|   458k|inline Content::ContentOneofCase Content::content_oneof_case() const {
11473|   458k|  return Content::ContentOneofCase(_impl_._oneof_case_[0]);
11474|   458k|}
_ZNK14xmlProtoFuzzer7Content13_internal_strEv:
11276|  2.54k|inline const std::string& Content::_internal_str() const {
11277|  2.54k|  if (_internal_has_str()) {
  ------------------
  |  Branch (11277:7): [True: 2.54k, False: 0]
  ------------------
11278|  2.54k|    return _impl_.content_oneof_.str_.Get();
11279|  2.54k|  }
11280|      0|  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
11281|  2.54k|}
_ZNK14xmlProtoFuzzer7Content11_internal_eEv:
11350|  6.58k|inline const ::xmlProtoFuzzer::Element& Content::_internal_e() const {
11351|  6.58k|  return _internal_has_e()
  ------------------
  |  Branch (11351:10): [True: 6.58k, False: 0]
  ------------------
11352|  6.58k|      ? *_impl_.content_oneof_.e_
11353|  6.58k|      : reinterpret_cast< ::xmlProtoFuzzer::Element&>(::xmlProtoFuzzer::_Element_default_instance_);
11354|  6.58k|}
_ZNK14xmlProtoFuzzer7Content11_internal_cEv:
11424|  3.27k|inline const ::xmlProtoFuzzer::CData& Content::_internal_c() const {
11425|  3.27k|  return _internal_has_c()
  ------------------
  |  Branch (11425:10): [True: 3.27k, False: 0]
  ------------------
11426|  3.27k|      ? *_impl_.content_oneof_.c_
11427|  3.27k|      : reinterpret_cast< ::xmlProtoFuzzer::CData&>(::xmlProtoFuzzer::_CData_default_instance_);
11428|  3.27k|}
_ZNK14xmlProtoFuzzer7Content17has_content_oneofEv:
11466|  21.2k|inline bool Content::has_content_oneof() const {
11467|  21.2k|  return content_oneof_case() != CONTENT_ONEOF_NOT_SET;
11468|  21.2k|}
_ZNK14xmlProtoFuzzer7Content17_internal_has_strEv:
11242|  2.54k|inline bool Content::_internal_has_str() const {
11243|  2.54k|  return content_oneof_case() == kStr;
11244|  2.54k|}
_ZNK14xmlProtoFuzzer7Content15_internal_has_eEv:
11319|  6.58k|inline bool Content::_internal_has_e() const {
11320|  6.58k|  return content_oneof_case() == kE;
11321|  6.58k|}
_ZNK14xmlProtoFuzzer7Content15_internal_has_cEv:
11393|  3.27k|inline bool Content::_internal_has_c() const {
11394|  3.27k|  return content_oneof_case() == kC;
11395|  3.27k|}
_ZNK14xmlProtoFuzzer7Element14_internal_nameEv:
11539|   410k|inline const std::string& Element::_internal_name() const {
11540|   410k|  return _impl_.name_.Get();
11541|   410k|}
_ZNK14xmlProtoFuzzer7Element19_internal_childpropEv:
11719|   391k|inline const std::string& Element::_internal_childprop() const {
11720|   391k|  return _impl_.childprop_.Get();
11721|   391k|}
_ZN14xmlProtoFuzzer7Element25internal_default_instanceEv:
 6089|   417k|  static inline const Element* internal_default_instance() {
 6090|   417k|    return reinterpret_cast<const Element*>(
 6091|   417k|               &_Element_default_instance_);
 6092|   417k|  }
_ZNK14xmlProtoFuzzer7Element14_internal_typeEv:
11483|   821k|inline ::xmlProtoFuzzer::Element_Type Element::_internal_type() const {
11484|   821k|  return static_cast< ::xmlProtoFuzzer::Element_Type >(_impl_.type_);
11485|   821k|}
_ZNK14xmlProtoFuzzer7Element12_internal_idEv:
11503|   782k|inline ::xmlProtoFuzzer::Element_Id Element::_internal_id() const {
11504|   782k|  return static_cast< ::xmlProtoFuzzer::Element_Id >(_impl_.id_);
11505|   782k|}
_ZNK14xmlProtoFuzzer7Element17_internal_contentEv:
11622|   410k|inline const ::xmlProtoFuzzer::Content& Element::_internal_content() const {
11623|   410k|  const ::xmlProtoFuzzer::Content* p = _impl_.content_;
11624|   410k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::Content&>(
  ------------------
  |  Branch (11624:10): [True: 19.1k, False: 391k]
  ------------------
11625|   391k|      ::xmlProtoFuzzer::_Content_default_instance_);
11626|   410k|}
_ZNK14xmlProtoFuzzer10VersionNum14_internal_typeEv:
11757|  17.0k|inline ::xmlProtoFuzzer::VersionNum_Type VersionNum::_internal_type() const {
11758|  17.0k|  return static_cast< ::xmlProtoFuzzer::VersionNum_Type >(_impl_.type_);
11759|  17.0k|}
_ZNK14xmlProtoFuzzer10VersionNum15_internal_majorEv:
11777|    144|inline uint64_t VersionNum::_internal_major() const {
11778|    144|  return _impl_.major_;
11779|    144|}
_ZNK14xmlProtoFuzzer10VersionNum15_internal_minorEv:
11797|    144|inline uint64_t VersionNum::_internal_minor() const {
11798|    144|  return _impl_.minor_;
11799|    144|}
_ZNK14xmlProtoFuzzer9Encodings14_internal_fuzzEv:
11857|    134|inline const std::string& Encodings::_internal_fuzz() const {
11858|    134|  return _impl_.fuzz_.Get();
11859|    134|}
_ZNK14xmlProtoFuzzer9Encodings14_internal_nameEv:
11821|  16.1k|inline ::xmlProtoFuzzer::Encodings_Enc Encodings::_internal_name() const {
11822|  16.1k|  return static_cast< ::xmlProtoFuzzer::Encodings_Enc >(_impl_.name_);
11823|  16.1k|}
_ZN14xmlProtoFuzzer14XmlDeclaration25internal_default_instanceEv:
 6834|  4.23k|  static inline const XmlDeclaration* internal_default_instance() {
 6835|  4.23k|    return reinterpret_cast<const XmlDeclaration*>(
 6836|  4.23k|               &_XmlDeclaration_default_instance_);
 6837|  4.23k|  }
_ZNK14xmlProtoFuzzer14XmlDeclaration20_internal_standaloneEv:
12075|  8.51k|inline ::xmlProtoFuzzer::XmlDeclaration_Standalone XmlDeclaration::_internal_standalone() const {
12076|  8.51k|  return static_cast< ::xmlProtoFuzzer::XmlDeclaration_Standalone >(_impl_.standalone_);
12077|  8.51k|}
_ZNK14xmlProtoFuzzer14XmlDeclaration13_internal_verEv:
11904|  8.51k|inline const ::xmlProtoFuzzer::VersionNum& XmlDeclaration::_internal_ver() const {
11905|  8.51k|  const ::xmlProtoFuzzer::VersionNum* p = _impl_.ver_;
11906|  8.51k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::VersionNum&>(
  ------------------
  |  Branch (11906:10): [True: 218, False: 8.29k]
  ------------------
11907|  8.29k|      ::xmlProtoFuzzer::_VersionNum_default_instance_);
11908|  8.51k|}
_ZNK14xmlProtoFuzzer14XmlDeclaration13_internal_encEv:
11994|  8.51k|inline const ::xmlProtoFuzzer::Encodings& XmlDeclaration::_internal_enc() const {
11995|  8.51k|  const ::xmlProtoFuzzer::Encodings* p = _impl_.enc_;
11996|  8.51k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::Encodings&>(
  ------------------
  |  Branch (11996:10): [True: 1.73k, False: 6.77k]
  ------------------
11997|  6.77k|      ::xmlProtoFuzzer::_Encodings_default_instance_);
11998|  8.51k|}
_ZN14xmlProtoFuzzer11XmlDocument25internal_default_instanceEv:
 7068|  8.78k|  static inline const XmlDocument* internal_default_instance() {
 7069|  8.78k|    return reinterpret_cast<const XmlDocument*>(
 7070|  8.78k|               &_XmlDocument_default_instance_);
 7071|  8.78k|  }
_ZNK14xmlProtoFuzzer11XmlDocument11_internal_pEv:
12158|  8.51k|inline const ::xmlProtoFuzzer::Prolog& XmlDocument::_internal_p() const {
12159|  8.51k|  const ::xmlProtoFuzzer::Prolog* p = _impl_.p_;
12160|  8.51k|  return p != nullptr ? *p : reinterpret_cast<const ::xmlProtoFuzzer::Prolog&>(
  ------------------
  |  Branch (12160:10): [True: 7.98k, False: 528]
  ------------------
12161|    528|      ::xmlProtoFuzzer::_Prolog_default_instance_);
12162|  8.51k|}
_ZNK14xmlProtoFuzzer4Misc3NewEPN6google8protobuf5ArenaE:
  700|  4.89k|  Misc* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
  701|  4.89k|    return CreateMaybeMessage<Misc>(arena);
  702|  4.89k|  }
_ZNK14xmlProtoFuzzer11ElementDecl3NewEPN6google8protobuf5ArenaE:
 1043|  5.73k|  ElementDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1044|  5.73k|    return CreateMaybeMessage<ElementDecl>(arena);
 1045|  5.73k|  }
_ZNK14xmlProtoFuzzer10ExternalId3NewEPN6google8protobuf5ArenaE:
 1835|  7.21k|  ExternalId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 1836|  7.21k|    return CreateMaybeMessage<ExternalId>(arena);
 1837|  7.21k|  }
_ZNK14xmlProtoFuzzer8AttValue3NewEPN6google8protobuf5ArenaE:
 2047|  2.69k|  AttValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2048|  2.69k|    return CreateMaybeMessage<AttValue>(arena);
 2049|  2.69k|  }
_ZNK14xmlProtoFuzzer11DefaultDecl3NewEPN6google8protobuf5ArenaE:
 2253|  4.58k|  DefaultDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2254|  4.58k|    return CreateMaybeMessage<DefaultDecl>(arena);
 2255|  4.58k|  }
_ZNK14xmlProtoFuzzer6AttDef3NewEPN6google8protobuf5ArenaE:
 2455|  19.2k|  AttDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2456|  19.2k|    return CreateMaybeMessage<AttDef>(arena);
 2457|  19.2k|  }
_ZNK14xmlProtoFuzzer11AttListDecl3NewEPN6google8protobuf5ArenaE:
 2683|  3.92k|  AttListDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2684|  3.92k|    return CreateMaybeMessage<AttListDecl>(arena);
 2685|  3.92k|  }
_ZNK14xmlProtoFuzzer12NotationDecl3NewEPN6google8protobuf5ArenaE:
 2863|  5.63k|  NotationDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 2864|  5.63k|    return CreateMaybeMessage<NotationDecl>(arena);
 2865|  5.63k|  }
_ZNK14xmlProtoFuzzer11EntityValue3NewEPN6google8protobuf5ArenaE:
 3090|  4.36k|  EntityValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3091|  4.36k|    return CreateMaybeMessage<EntityValue>(arena);
 3092|  4.36k|  }
_ZNK14xmlProtoFuzzer9NDataDecl3NewEPN6google8protobuf5ArenaE:
 3298|  1.71k|  NDataDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3299|  1.71k|    return CreateMaybeMessage<NDataDecl>(arena);
 3300|  1.71k|  }
_ZNK14xmlProtoFuzzer9EntityDef3NewEPN6google8protobuf5ArenaE:
 3457|  7.68k|  EntityDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3458|  7.68k|    return CreateMaybeMessage<EntityDef>(arena);
 3459|  7.68k|  }
_ZNK14xmlProtoFuzzer5PEDef3NewEPN6google8protobuf5ArenaE:
 3673|  3.42k|  PEDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3674|  3.42k|    return CreateMaybeMessage<PEDef>(arena);
 3675|  3.42k|  }
_ZNK14xmlProtoFuzzer10EntityDecl3NewEPN6google8protobuf5ArenaE:
 3863|  13.0k|  EntityDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 3864|  13.0k|    return CreateMaybeMessage<EntityDecl>(arena);
 3865|  13.0k|  }
_ZNK14xmlProtoFuzzer15ConditionalSect3NewEPN6google8protobuf5ArenaE:
 4097|  7.30k|  ConditionalSect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4098|  7.30k|    return CreateMaybeMessage<ConditionalSect>(arena);
 4099|  7.30k|  }
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl3NewEPN6google8protobuf5ArenaE:
 4329|  34.5k|  OneExtSubsetDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4330|  34.5k|    return CreateMaybeMessage<OneExtSubsetDecl>(arena);
 4331|  34.5k|  }
_ZNK14xmlProtoFuzzer13ExtSubsetDecl3NewEPN6google8protobuf5ArenaE:
 4519|  8.80k|  ExtSubsetDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4520|  8.80k|    return CreateMaybeMessage<ExtSubsetDecl>(arena);
 4521|  8.80k|  }
_ZNK14xmlProtoFuzzer10MarkupDecl3NewEPN6google8protobuf5ArenaE:
 4686|  42.0k|  MarkupDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4687|  42.0k|    return CreateMaybeMessage<MarkupDecl>(arena);
 4688|  42.0k|  }
_ZNK14xmlProtoFuzzer11DocTypeDecl3NewEPN6google8protobuf5ArenaE:
 4960|  7.75k|  DocTypeDecl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 4961|  7.75k|    return CreateMaybeMessage<DocTypeDecl>(arena);
 4962|  7.75k|  }
_ZNK14xmlProtoFuzzer6Prolog3NewEPN6google8protobuf5ArenaE:
 5153|  8.20k|  Prolog* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 5154|  8.20k|    return CreateMaybeMessage<Prolog>(arena);
 5155|  8.20k|  }
_ZNK14xmlProtoFuzzer8KeyValue3NewEPN6google8protobuf5ArenaE:
 5350|  34.2k|  KeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 5351|  34.2k|    return CreateMaybeMessage<KeyValue>(arena);
 5352|  34.2k|  }
_ZNK14xmlProtoFuzzer21ProcessingInstruction3NewEPN6google8protobuf5ArenaE:
 5576|  1.51k|  ProcessingInstruction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 5577|  1.51k|    return CreateMaybeMessage<ProcessingInstruction>(arena);
 5578|  1.51k|  }
_ZNK14xmlProtoFuzzer5CData3NewEPN6google8protobuf5ArenaE:
 5749|  3.65k|  CData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 5750|  3.65k|    return CreateMaybeMessage<CData>(arena);
 5751|  3.65k|  }
_ZNK14xmlProtoFuzzer7Content3NewEPN6google8protobuf5ArenaE:
 5909|  21.2k|  Content* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 5910|  21.2k|    return CreateMaybeMessage<Content>(arena);
 5911|  21.2k|  }
_ZNK14xmlProtoFuzzer7Element3NewEPN6google8protobuf5ArenaE:
 6120|   417k|  Element* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 6121|   417k|    return CreateMaybeMessage<Element>(arena);
 6122|   417k|  }
_ZNK14xmlProtoFuzzer10VersionNum3NewEPN6google8protobuf5ArenaE:
 6423|    224|  VersionNum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 6424|    224|    return CreateMaybeMessage<VersionNum>(arena);
 6425|    224|  }
_ZNK14xmlProtoFuzzer9Encodings3NewEPN6google8protobuf5ArenaE:
 6623|  1.75k|  Encodings* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 6624|  1.75k|    return CreateMaybeMessage<Encodings>(arena);
 6625|  1.75k|  }
_ZNK14xmlProtoFuzzer14XmlDeclaration3NewEPN6google8protobuf5ArenaE:
 6865|  2.11k|  XmlDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
 6866|  2.11k|    return CreateMaybeMessage<XmlDeclaration>(arena);
 6867|  2.11k|  }
_ZN14xmlProtoFuzzer11ElementDecl19ContentSpec_IsValidEi:
 1098|  5.70k|  static inline bool ContentSpec_IsValid(int value) {
 1099|  5.70k|    return ElementDecl_ContentSpec_IsValid(value);
 1100|  5.70k|  }
_ZN14xmlProtoFuzzer10ExternalId12Type_IsValidEi:
 1886|  14.5k|  static inline bool Type_IsValid(int value) {
 1887|  14.5k|    return ExternalId_Type_IsValid(value);
 1888|  14.5k|  }
_ZN14xmlProtoFuzzer8AttValue12Type_IsValidEi:
 2098|  3.16k|  static inline bool Type_IsValid(int value) {
 2099|  3.16k|    return AttValue_Type_IsValid(value);
 2100|  3.16k|  }
_ZN14xmlProtoFuzzer11DefaultDecl12Type_IsValidEi:
 2306|  18.7k|  static inline bool Type_IsValid(int value) {
 2307|  18.7k|    return DefaultDecl_Type_IsValid(value);
 2308|  18.7k|  }
_ZN14xmlProtoFuzzer6AttDef12Type_IsValidEi:
 2518|  18.8k|  static inline bool Type_IsValid(int value) {
 2519|  18.8k|    return AttDef_Type_IsValid(value);
 2520|  18.8k|  }
_ZN14xmlProtoFuzzer11EntityValue12Type_IsValidEi:
 3143|  4.19k|  static inline bool Type_IsValid(int value) {
 3144|  4.19k|    return EntityValue_Type_IsValid(value);
 3145|  4.19k|  }
_ZN14xmlProtoFuzzer10EntityDecl12Type_IsValidEi:
 3912|  12.4k|  static inline bool Type_IsValid(int value) {
 3913|  12.4k|    return EntityDecl_Type_IsValid(value);
 3914|  12.4k|  }
_ZN14xmlProtoFuzzer15ConditionalSect12Type_IsValidEi:
 4148|  7.06k|  static inline bool Type_IsValid(int value) {
 4149|  7.06k|    return ConditionalSect_Type_IsValid(value);
 4150|  7.06k|  }
_ZN14xmlProtoFuzzer8KeyValue20XmlNamespace_IsValidEi:
 5415|  31.7k|  static inline bool XmlNamespace_IsValid(int value) {
 5416|  31.7k|    return KeyValue_XmlNamespace_IsValid(value);
 5417|  31.7k|  }
_ZN14xmlProtoFuzzer7Element12Type_IsValidEi:
 6169|   410k|  static inline bool Type_IsValid(int value) {
 6170|   410k|    return Element_Type_IsValid(value);
 6171|   410k|  }
_ZN14xmlProtoFuzzer7Element10Id_IsValidEi:
 6211|   391k|  static inline bool Id_IsValid(int value) {
 6212|   391k|    return Element_Id_IsValid(value);
 6213|   391k|  }
_ZN14xmlProtoFuzzer10VersionNum12Type_IsValidEi:
 6472|  8.51k|  static inline bool Type_IsValid(int value) {
 6473|  8.51k|    return VersionNum_Type_IsValid(value);
 6474|  8.51k|  }
_ZN14xmlProtoFuzzer9Encodings11Enc_IsValidEi:
 6720|  8.51k|  static inline bool Enc_IsValid(int value) {
 6721|  8.51k|    return Encodings_Enc_IsValid(value);
 6722|  8.51k|  }
_ZN14xmlProtoFuzzer11XmlDocumentC2Ev:
 7028|  8.78k|  inline XmlDocument() : XmlDocument(nullptr) {}
_ZNK14xmlProtoFuzzer4Misc7commentEv:
 7227|  1.72k|inline const std::string& Misc::comment() const {
 7228|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Misc.comment)
 7229|  1.72k|  return _internal_comment();
 7230|  1.72k|}
_ZNK14xmlProtoFuzzer4Misc4instEv:
 7325|  1.37k|inline const ::xmlProtoFuzzer::ProcessingInstruction& Misc::inst() const {
 7326|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Misc.inst)
 7327|  1.37k|  return _internal_inst();
 7328|  1.37k|}
_ZNK14xmlProtoFuzzer11ElementDecl4nameEv:
 7433|  5.66k|inline const std::string& ElementDecl::name() const {
 7434|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ElementDecl.name)
 7435|  5.66k|  return _internal_name();
 7436|  5.66k|}
_ZNK14xmlProtoFuzzer11ElementDecl4specEv:
 7486|  11.3k|inline ::xmlProtoFuzzer::ElementDecl_ContentSpec ElementDecl::spec() const {
 7487|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ElementDecl.spec)
 7488|  11.3k|  return _internal_spec();
 7489|  11.3k|}
_ZNK14xmlProtoFuzzer11ElementDecl10cdata_sizeEv:
 7503|  1.11k|inline int ElementDecl::cdata_size() const {
 7504|  1.11k|  return _internal_cdata_size();
 7505|  1.11k|}
_ZNK14xmlProtoFuzzer11ElementDecl5cdataEv:
 7564|  1.79k|ElementDecl::cdata() const {
 7565|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.ElementDecl.cdata)
 7566|  1.79k|  return _impl_.cdata_;
 7567|  1.79k|}
_ZNK14xmlProtoFuzzer10ExternalId4typeEv:
 8012|  27.8k|inline ::xmlProtoFuzzer::ExternalId_Type ExternalId::type() const {
 8013|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ExternalId.type)
 8014|  27.8k|  return _internal_type();
 8015|  27.8k|}
_ZNK14xmlProtoFuzzer10ExternalId6systemEv:
 8029|  12.6k|inline const std::string& ExternalId::system() const {
 8030|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ExternalId.system)
 8031|  12.6k|  return _internal_system();
 8032|  12.6k|}
_ZNK14xmlProtoFuzzer10ExternalId3pubEv:
 8079|  1.88k|inline const std::string& ExternalId::pub() const {
 8080|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ExternalId.pub)
 8081|  1.88k|  return _internal_pub();
 8082|  1.88k|}
_ZNK14xmlProtoFuzzer8AttValue4typeEv:
 8136|  6.00k|inline ::xmlProtoFuzzer::AttValue_Type AttValue::type() const {
 8137|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.AttValue.type)
 8138|  6.00k|  return _internal_type();
 8139|  6.00k|}
_ZNK14xmlProtoFuzzer8AttValue5valueEv:
 8214|  2.83k|AttValue::value() const {
 8215|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.AttValue.value)
 8216|  2.83k|  return _impl_.value_;
 8217|  2.83k|}
_ZNK14xmlProtoFuzzer11DefaultDecl4typeEv:
 8235|  37.3k|inline ::xmlProtoFuzzer::DefaultDecl_Type DefaultDecl::type() const {
 8236|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.DefaultDecl.type)
 8237|  37.3k|  return _internal_type();
 8238|  37.3k|}
_ZNK14xmlProtoFuzzer11DefaultDecl3attEv:
 8266|  3.16k|inline const ::xmlProtoFuzzer::AttValue& DefaultDecl::att() const {
 8267|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.DefaultDecl.att)
 8268|  3.16k|  return _internal_att();
 8269|  3.16k|}
_ZNK14xmlProtoFuzzer6AttDef4nameEv:
 8346|  18.7k|inline const std::string& AttDef::name() const {
 8347|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.AttDef.name)
 8348|  18.7k|  return _internal_name();
 8349|  18.7k|}
_ZNK14xmlProtoFuzzer6AttDef4typeEv:
 8399|  37.6k|inline ::xmlProtoFuzzer::AttDef_Type AttDef::type() const {
 8400|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.AttDef.type)
 8401|  37.6k|  return _internal_type();
 8402|  37.6k|}
_ZNK14xmlProtoFuzzer6AttDef3defEv:
 8430|  18.7k|inline const ::xmlProtoFuzzer::DefaultDecl& AttDef::def() const {
 8431|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.AttDef.def)
 8432|  18.7k|  return _internal_def();
 8433|  18.7k|}
_ZNK14xmlProtoFuzzer11AttListDecl4nameEv:
 8510|  3.81k|inline const std::string& AttListDecl::name() const {
 8511|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.AttListDecl.name)
 8512|  3.81k|  return _internal_name();
 8513|  3.81k|}
_ZNK14xmlProtoFuzzer11AttListDecl7attdefsEv:
 8591|  3.81k|AttListDecl::attdefs() const {
 8592|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.AttListDecl.attdefs)
 8593|  3.81k|  return _impl_.attdefs_;
 8594|  3.81k|}
_ZNK14xmlProtoFuzzer12NotationDecl4nameEv:
 8604|  5.15k|inline const std::string& NotationDecl::name() const {
 8605|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.NotationDecl.name)
 8606|  5.15k|  return _internal_name();
 8607|  5.15k|}
_ZNK14xmlProtoFuzzer12NotationDecl3extEv:
 8687|  1.05k|inline const ::xmlProtoFuzzer::ExternalId& NotationDecl::ext() const {
 8688|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.NotationDecl.ext)
 8689|  1.05k|  return _internal_ext();
 8690|  1.05k|}
_ZNK14xmlProtoFuzzer12NotationDecl3pubEv:
 8740|  2.72k|inline const std::string& NotationDecl::pub() const {
 8741|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.NotationDecl.pub)
 8742|  2.72k|  return _internal_pub();
 8743|  2.72k|}
_ZNK14xmlProtoFuzzer12NotationDecl4fuzzEv:
 8817|    661|inline const std::string& NotationDecl::fuzz() const {
 8818|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.NotationDecl.fuzz)
 8819|    661|  return _internal_fuzz();
 8820|    661|}
_ZNK14xmlProtoFuzzer11EntityValue4typeEv:
 8898|  8.32k|inline ::xmlProtoFuzzer::EntityValue_Type EntityValue::type() const {
 8899|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityValue.type)
 8900|  8.32k|  return _internal_type();
 8901|  8.32k|}
_ZNK14xmlProtoFuzzer11EntityValue4nameEv:
 8976|  4.12k|EntityValue::name() const {
 8977|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.EntityValue.name)
 8978|  4.12k|  return _impl_.name_;
 8979|  4.12k|}
_ZNK14xmlProtoFuzzer9NDataDecl4nameEv:
 8994|  1.75k|inline const std::string& NDataDecl::name() const {
 8995|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.NDataDecl.name)
 8996|  1.75k|  return _internal_name();
 8997|  1.75k|}
_ZNK14xmlProtoFuzzer9EntityDef3extEv:
 9081|  4.11k|inline const ::xmlProtoFuzzer::ExternalId& EntityDef::ext() const {
 9082|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDef.ext)
 9083|  4.11k|  return _internal_ext();
 9084|  4.11k|}
_ZNK14xmlProtoFuzzer9EntityDef3valEv:
 9155|  2.82k|inline const ::xmlProtoFuzzer::EntityValue& EntityDef::val() const {
 9156|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDef.val)
 9157|  2.82k|  return _internal_val();
 9158|  2.82k|}
_ZNK14xmlProtoFuzzer9EntityDef5ndataEv:
 9210|  1.75k|inline const ::xmlProtoFuzzer::NDataDecl& EntityDef::ndata() const {
 9211|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDef.ndata)
 9212|  1.75k|  return _internal_ndata();
 9213|  1.75k|}
_ZNK14xmlProtoFuzzer5PEDef3valEv:
 9332|  1.37k|inline const ::xmlProtoFuzzer::EntityValue& PEDef::val() const {
 9333|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.PEDef.val)
 9334|  1.37k|  return _internal_val();
 9335|  1.37k|}
_ZNK14xmlProtoFuzzer5PEDef2idEv:
 9406|    837|inline const ::xmlProtoFuzzer::ExternalId& PEDef::id() const {
 9407|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.PEDef.id)
 9408|    837|  return _internal_id();
 9409|    837|}
_ZNK14xmlProtoFuzzer10EntityDecl4typeEv:
 9463|  24.8k|inline ::xmlProtoFuzzer::EntityDecl_Type EntityDecl::type() const {
 9464|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDecl.type)
 9465|  24.8k|  return _internal_type();
 9466|  24.8k|}
_ZNK14xmlProtoFuzzer10EntityDecl4nameEv:
 9480|  12.3k|inline const std::string& EntityDecl::name() const {
 9481|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDecl.name)
 9482|  12.3k|  return _internal_name();
 9483|  12.3k|}
_ZNK14xmlProtoFuzzer10EntityDecl3entEv:
 9544|  8.98k|inline const ::xmlProtoFuzzer::EntityDef& EntityDecl::ent() const {
 9545|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDecl.ent)
 9546|  8.98k|  return _internal_ent();
 9547|  8.98k|}
_ZNK14xmlProtoFuzzer10EntityDecl5pedefEv:
 9634|  3.36k|inline const ::xmlProtoFuzzer::PEDef& EntityDecl::pedef() const {
 9635|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.EntityDecl.pedef)
 9636|  3.36k|  return _internal_pedef();
 9637|  3.36k|}
_ZNK14xmlProtoFuzzer15ConditionalSect4typeEv:
 9717|  13.9k|inline ::xmlProtoFuzzer::ConditionalSect_Type ConditionalSect::type() const {
 9718|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ConditionalSect.type)
 9719|  13.9k|  return _internal_type();
 9720|  13.9k|}
_ZNK14xmlProtoFuzzer15ConditionalSect3extEv:
 9748|  5.96k|inline const ::xmlProtoFuzzer::ExtSubsetDecl& ConditionalSect::ext() const {
 9749|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ConditionalSect.ext)
 9750|  5.96k|  return _internal_ext();
 9751|  5.96k|}
_ZNK14xmlProtoFuzzer15ConditionalSect7ignoresEv:
 9885|    882|ConditionalSect::ignores() const {
 9886|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.ConditionalSect.ignores)
 9887|    882|  return _impl_.ignores_;
 9888|    882|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl1mEv:
 9936|  19.1k|inline const ::xmlProtoFuzzer::MarkupDecl& OneExtSubsetDecl::m() const {
 9937|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.OneExtSubsetDecl.m)
 9938|  19.1k|  return _internal_m();
 9939|  19.1k|}
_ZNK14xmlProtoFuzzer16OneExtSubsetDecl1cEv:
10010|  7.06k|inline const ::xmlProtoFuzzer::ConditionalSect& OneExtSubsetDecl::c() const {
10011|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.OneExtSubsetDecl.c)
10012|  7.06k|  return _internal_c();
10013|  7.06k|}
_ZNK14xmlProtoFuzzer13ExtSubsetDecl5declsEv:
10095|  11.0k|ExtSubsetDecl::decls() const {
10096|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.ExtSubsetDecl.decls)
10097|  11.0k|  return _impl_.decls_;
10098|  11.0k|}
_ZNK14xmlProtoFuzzer10MarkupDecl1eEv:
10141|  5.70k|inline const ::xmlProtoFuzzer::ElementDecl& MarkupDecl::e() const {
10142|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.MarkupDecl.e)
10143|  5.70k|  return _internal_e();
10144|  5.70k|}
_ZNK14xmlProtoFuzzer10MarkupDecl1aEv:
10215|  3.81k|inline const ::xmlProtoFuzzer::AttListDecl& MarkupDecl::a() const {
10216|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.MarkupDecl.a)
10217|  3.81k|  return _internal_a();
10218|  3.81k|}
_ZNK14xmlProtoFuzzer10MarkupDecl1nEv:
10289|  5.15k|inline const ::xmlProtoFuzzer::NotationDecl& MarkupDecl::n() const {
10290|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.MarkupDecl.n)
10291|  5.15k|  return _internal_n();
10292|  5.15k|}
_ZNK14xmlProtoFuzzer10MarkupDecl1mEv:
10363|  1.91k|inline const ::xmlProtoFuzzer::Misc& MarkupDecl::m() const {
10364|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.MarkupDecl.m)
10365|  1.91k|  return _internal_m();
10366|  1.91k|}
_ZNK14xmlProtoFuzzer10MarkupDecl6entityEv:
10437|  12.4k|inline const ::xmlProtoFuzzer::EntityDecl& MarkupDecl::entity() const {
10438|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.MarkupDecl.entity)
10439|  12.4k|  return _internal_entity();
10440|  12.4k|}
_ZNK14xmlProtoFuzzer10MarkupDecl3extEv:
10511|  5.03k|inline const ::xmlProtoFuzzer::ExtSubsetDecl& MarkupDecl::ext() const {
10512|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.MarkupDecl.ext)
10513|  5.03k|  return _internal_ext();
10514|  5.03k|}
_ZNK14xmlProtoFuzzer11DocTypeDecl4nameEv:
10565|  8.51k|inline const std::string& DocTypeDecl::name() const {
10566|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.DocTypeDecl.name)
10567|  8.51k|  return _internal_name();
10568|  8.51k|}
_ZNK14xmlProtoFuzzer11DocTypeDecl3extEv:
10629|  8.51k|inline const ::xmlProtoFuzzer::ExternalId& DocTypeDecl::ext() const {
10630|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.DocTypeDecl.ext)
10631|  8.51k|  return _internal_ext();
10632|  8.51k|}
_ZNK14xmlProtoFuzzer11DocTypeDecl5mdeclEv:
10736|  8.51k|DocTypeDecl::mdecl() const {
10737|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.DocTypeDecl.mdecl)
10738|  8.51k|  return _impl_.mdecl_;
10739|  8.51k|}
_ZNK14xmlProtoFuzzer6Prolog4declEv:
10763|  8.51k|inline const ::xmlProtoFuzzer::XmlDeclaration& Prolog::decl() const {
10764|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Prolog.decl)
10765|  8.51k|  return _internal_decl();
10766|  8.51k|}
_ZNK14xmlProtoFuzzer6Prolog7doctypeEv:
10853|  8.51k|inline const ::xmlProtoFuzzer::DocTypeDecl& Prolog::doctype() const {
10854|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Prolog.doctype)
10855|  8.51k|  return _internal_doctype();
10856|  8.51k|}
_ZNK14xmlProtoFuzzer6Prolog4miscEv:
10960|  8.51k|Prolog::misc() const {
10961|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.Prolog.misc)
10962|  8.51k|  return _impl_.misc_;
10963|  8.51k|}
_ZNK14xmlProtoFuzzer8KeyValue4typeEv:
10976|  63.2k|inline ::xmlProtoFuzzer::KeyValue_XmlNamespace KeyValue::type() const {
10977|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.KeyValue.type)
10978|  63.2k|  return _internal_type();
10979|  63.2k|}
_ZNK14xmlProtoFuzzer8KeyValue3keyEv:
10993|  10.7k|inline const std::string& KeyValue::key() const {
10994|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.KeyValue.key)
10995|  10.7k|  return _internal_key();
10996|  10.7k|}
_ZNK14xmlProtoFuzzer8KeyValue5valueEv:
11043|  31.5k|inline const std::string& KeyValue::value() const {
11044|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.KeyValue.value)
11045|  31.5k|  return _internal_value();
11046|  31.5k|}
_ZNK14xmlProtoFuzzer21ProcessingInstruction4nameEv:
11097|  1.37k|inline const std::string& ProcessingInstruction::name() const {
11098|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.ProcessingInstruction.name)
11099|  1.37k|  return _internal_name();
11100|  1.37k|}
_ZNK14xmlProtoFuzzer21ProcessingInstruction2kvEv:
11178|  1.37k|ProcessingInstruction::kv() const {
11179|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.ProcessingInstruction.kv)
11180|  1.37k|  return _impl_.kv_;
11181|  1.37k|}
_ZNK14xmlProtoFuzzer5CData4dataEv:
11191|  3.27k|inline const std::string& CData::data() const {
11192|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.CData.data)
11193|  3.27k|  return _internal_data();
11194|  3.27k|}
_ZNK14xmlProtoFuzzer7Content3strEv:
11257|  2.54k|inline const std::string& Content::str() const {
11258|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Content.str)
11259|  2.54k|  return _internal_str();
11260|  2.54k|}
_ZNK14xmlProtoFuzzer7Content1eEv:
11355|  6.58k|inline const ::xmlProtoFuzzer::Element& Content::e() const {
11356|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Content.e)
11357|  6.58k|  return _internal_e();
11358|  6.58k|}
_ZNK14xmlProtoFuzzer7Content1cEv:
11429|  3.27k|inline const ::xmlProtoFuzzer::CData& Content::c() const {
11430|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Content.c)
11431|  3.27k|  return _internal_c();
11432|  3.27k|}
_ZNK14xmlProtoFuzzer7Element4typeEv:
11486|   821k|inline ::xmlProtoFuzzer::Element_Type Element::type() const {
11487|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Element.type)
11488|   821k|  return _internal_type();
11489|   821k|}
_ZNK14xmlProtoFuzzer7Element2idEv:
11506|   782k|inline ::xmlProtoFuzzer::Element_Id Element::id() const {
11507|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Element.id)
11508|   782k|  return _internal_id();
11509|   782k|}
_ZNK14xmlProtoFuzzer7Element4nameEv:
11523|   410k|inline const std::string& Element::name() const {
11524|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Element.name)
11525|   410k|  return _internal_name();
11526|   410k|}
_ZNK14xmlProtoFuzzer7Element2kvEv:
11604|   410k|Element::kv() const {
11605|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.Element.kv)
11606|   410k|  return _impl_.kv_;
11607|   410k|}
_ZNK14xmlProtoFuzzer7Element7contentEv:
11627|   410k|inline const ::xmlProtoFuzzer::Content& Element::content() const {
11628|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Element.content)
11629|   410k|  return _internal_content();
11630|   410k|}
_ZNK14xmlProtoFuzzer7Element9childpropEv:
11703|   391k|inline const std::string& Element::childprop() const {
11704|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Element.childprop)
11705|   391k|  return _internal_childprop();
11706|   391k|}
_ZNK14xmlProtoFuzzer10VersionNum4typeEv:
11760|  17.0k|inline ::xmlProtoFuzzer::VersionNum_Type VersionNum::type() const {
11761|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.VersionNum.type)
11762|  17.0k|  return _internal_type();
11763|  17.0k|}
_ZNK14xmlProtoFuzzer10VersionNum5majorEv:
11780|    144|inline uint64_t VersionNum::major() const {
11781|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.VersionNum.major)
11782|    144|  return _internal_major();
11783|    144|}
_ZNK14xmlProtoFuzzer10VersionNum5minorEv:
11800|    144|inline uint64_t VersionNum::minor() const {
11801|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.VersionNum.minor)
11802|    144|  return _internal_minor();
11803|    144|}
_ZNK14xmlProtoFuzzer9Encodings4nameEv:
11824|  16.1k|inline ::xmlProtoFuzzer::Encodings_Enc Encodings::name() const {
11825|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Encodings.name)
11826|  16.1k|  return _internal_name();
11827|  16.1k|}
_ZNK14xmlProtoFuzzer9Encodings4fuzzEv:
11841|    134|inline const std::string& Encodings::fuzz() const {
11842|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.Encodings.fuzz)
11843|    134|  return _internal_fuzz();
11844|    134|}
_ZNK14xmlProtoFuzzer14XmlDeclaration3verEv:
11909|  8.51k|inline const ::xmlProtoFuzzer::VersionNum& XmlDeclaration::ver() const {
11910|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.XmlDeclaration.ver)
11911|  8.51k|  return _internal_ver();
11912|  8.51k|}
_ZNK14xmlProtoFuzzer14XmlDeclaration3encEv:
11999|  8.51k|inline const ::xmlProtoFuzzer::Encodings& XmlDeclaration::enc() const {
12000|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.XmlDeclaration.enc)
12001|  8.51k|  return _internal_enc();
12002|  8.51k|}
_ZNK14xmlProtoFuzzer14XmlDeclaration10standaloneEv:
12078|  8.51k|inline ::xmlProtoFuzzer::XmlDeclaration_Standalone XmlDeclaration::standalone() const {
12079|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.XmlDeclaration.standalone)
12080|  8.51k|  return _internal_standalone();
12081|  8.51k|}
_ZNK14xmlProtoFuzzer11XmlDocument1pEv:
12163|  8.51k|inline const ::xmlProtoFuzzer::Prolog& XmlDocument::p() const {
12164|       |  // @@protoc_insertion_point(field_get:xmlProtoFuzzer.XmlDocument.p)
12165|  8.51k|  return _internal_p();
12166|  8.51k|}
_ZNK14xmlProtoFuzzer11XmlDocument1eEv:
12270|  8.51k|XmlDocument::e() const {
12271|       |  // @@protoc_insertion_point(field_list:xmlProtoFuzzer.XmlDocument.e)
12272|  8.51k|  return _impl_.e_;
12273|  8.51k|}

parse_target_proto.cpp:_ZL17TestOneProtoInputRKN14xmlProtoFuzzer11XmlDocumentE:
   42|  8.51k|DEFINE_PROTO_FUZZER(const xmlProtoFuzzer::XmlDocument& xmlDocument) {
   43|  8.51k|    std::string xmlData = xmlProtoFuzzer::ProtoConverter().protoToString(xmlDocument);
   44|  8.51k|    parseInMemory((const uint8_t *)xmlData.c_str(), xmlData.size());
   45|  8.51k|}

_ZN11xercesc_3_211DOMDocumentC2Ev:
   76|      1|    DOMDocument() {};

_ZN11xercesc_3_216DOMDocumentRangeC2Ev:
   45|      1|    DOMDocumentRange() {};

_ZN11xercesc_3_220DOMDocumentTraversalC2Ev:
   55|      1|    DOMDocumentTraversal() {};

_ZN11xercesc_3_217DOMImplementationC2Ev:
   51|      1|        DOMImplementation() {};                                      // no plain constructor

_ZN11xercesc_3_219DOMImplementationLSC2Ev:
   57|      1|    DOMImplementationLS() {};

_ZN11xercesc_3_223DOMImplementationSourceC2Ev:
   50|      1|    DOMImplementationSource() {};

_ZN11xercesc_3_217DOMLSParserFilterC2Ev:
   52|      2|    DOMLSParserFilter() {};

_ZN11xercesc_3_216DOMMemoryManagerC2Ev:
   40|      1|    DOMMemoryManager() {};

_ZN11xercesc_3_27DOMNodeC2Ev:
  146|      1|    DOMNode() {}

_ZN11xercesc_3_211DOMNodeListC2Ev:
   52|      2|    DOMNodeList() {};

_ZN11xercesc_3_215DOMPSVITypeInfoC2Ev:
   42|     24|    DOMPSVITypeInfo() {};

_ZN11xercesc_3_211DOMTypeInfoC2Ev:
   43|     24|    DOMTypeInfo() {};

_ZN11xercesc_3_217DOMXPathEvaluatorC2Ev:
   56|      1|    DOMXPathEvaluator() {};

_ZN11xercesc_3_215DOMDocumentImplC2EPNS_17DOMImplementationEPNS_13MemoryManagerE:
  111|      1|{
  112|      1|    fNameTable = (DOMStringPoolEntry**)allocate (
  113|      1|      sizeof (DOMStringPoolEntry*) * fNameTableSize);
  114|    258|    for (XMLSize_t i = 0; i < fNameTableSize; i++)
  ------------------
  |  Branch (114:27): [True: 257, False: 1]
  ------------------
  115|    257|      fNameTable[i] = 0;
  116|      1|}
_ZN11xercesc_3_215DOMDocumentImpl8allocateEm:
  858|      1|{
  859|       |  //	Align the request size so that suballocated blocks
  860|       |  //	beyond this one will be maintained at the same alignment.
  861|      1|  amount = XMLPlatformUtils::alignPointerForNewBlockAllocation(amount);
  862|       |
  863|       |  // If the request is for a largish block, hand it off to the system
  864|       |  //   allocator.  The block still must be linked into a special list of
  865|       |  //   allocated big blocks so that it will be deleted when the time comes.
  866|      1|  if (amount > kMaxSubAllocationSize)
  ------------------
  |  Branch (866:7): [True: 1, False: 0]
  ------------------
  867|      1|  {
  868|       |    //	The size of the header we add to our raw blocks
  869|      1|    XMLSize_t sizeOfHeader = XMLPlatformUtils::alignPointerForNewBlockAllocation(sizeof(void *));
  870|       |
  871|       |    //	Try to allocate the block
  872|      1|    void* newBlock = fMemoryManager->allocate(sizeOfHeader + amount);
  873|       |
  874|       |    //	Link it into the list beyond current block, as current block
  875|       |    //	is still being subdivided. If there is no current block
  876|       |    //	then track that we have no bytes to further divide.
  877|      1|    if (fCurrentSingletonBlock)
  ------------------
  |  Branch (877:9): [True: 0, False: 1]
  ------------------
  878|      0|    {
  879|      0|      *(void **)newBlock = *(void **)fCurrentSingletonBlock;
  880|      0|      *(void **)fCurrentSingletonBlock = newBlock;
  881|      0|    }
  882|      1|    else
  883|      1|    {
  884|      1|      *(void **)newBlock = 0;
  885|      1|      fCurrentSingletonBlock = newBlock;
  886|      1|    }
  887|       |
  888|      1|    void *retPtr = (char*)newBlock + sizeOfHeader;
  889|      1|    return retPtr;
  890|      1|  }
  891|       |
  892|       |  //	It's a normal (sub-allocatable) request.
  893|       |  //	Are we out of room in our current block?
  894|      0|  if (amount > fFreeBytesRemaining)
  ------------------
  |  Branch (894:7): [True: 0, False: 0]
  ------------------
  895|      0|  {
  896|       |    // Request doesn't fit in the current block.
  897|       |    // The size of the header we add to our raw blocks
  898|      0|    XMLSize_t sizeOfHeader = XMLPlatformUtils::alignPointerForNewBlockAllocation(sizeof(void *));
  899|       |
  900|       |    // Get a new block from the system allocator.
  901|      0|    void* newBlock;
  902|      0|    newBlock = fMemoryManager->allocate(fHeapAllocSize);
  903|       |
  904|      0|    *(void **)newBlock = fCurrentBlock;
  905|      0|    fCurrentBlock = newBlock;
  906|      0|    fFreePtr = (char *)newBlock + sizeOfHeader;
  907|      0|    fFreeBytesRemaining = fHeapAllocSize - sizeOfHeader;
  908|       |
  909|      0|    if(fHeapAllocSize<kMaxHeapAllocSize)
  ------------------
  |  Branch (909:8): [True: 0, False: 0]
  ------------------
  910|      0|      fHeapAllocSize*=2;
  911|      0|  }
  912|       |
  913|       |  //	Subdivide the request off current block
  914|      0|  void *retPtr = fFreePtr;
  915|      0|  fFreePtr += amount;
  916|      0|  fFreeBytesRemaining -= amount;
  917|       |
  918|      0|  return retPtr;
  919|      1|}

_ZN11xercesc_3_214XMLInitializer29initializeDOMDocumentTypeImplEv:
   43|      1|{
   44|      1|    sDocumentMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
   45|       |
   46|      1|    static const XMLCh gCoreStr[] = { chLatin_C, chLatin_o, chLatin_r, chLatin_e, chNull };
   47|      1|    DOMImplementation* impl =  DOMImplementationRegistry::getDOMImplementation(gCoreStr);
   48|      1|    sDocument = impl->createDocument(); // document type object (DTD).
   49|      1|}

_ZN11xercesc_3_214XMLInitializer31initializeDOMImplementationImplEv:
   71|      1|{
   72|      1|    sMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgXMLDOMMsgDomain);
   73|       |
   74|      1|    if (!sMsgLoader)
  ------------------
  |  Branch (74:9): [True: 0, False: 1]
  ------------------
   75|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   76|       |
   77|      1|    gDomimp = new DOMImplementationImpl;
   78|      1|}
_ZN11xercesc_3_221DOMImplementationImpl24getDOMImplementationImplEv:
   97|      2|{
   98|      2|    return gDomimp;
   99|      2|}
_ZNK11xercesc_3_221DOMImplementationImpl10hasFeatureEPKDsS2_:
  105|      1|{
  106|      1|    if (!feature)
  ------------------
  |  Branch (106:9): [True: 0, False: 1]
  ------------------
  107|      0|        return false;
  108|       |
  109|       |    // ignore the + modifier
  110|      1|    if(*feature==chPlus)
  ------------------
  |  Branch (110:8): [True: 0, False: 1]
  ------------------
  111|      0|        feature++;
  112|       |
  113|      1|    bool anyVersion = (version == 0 || !*version);
  ------------------
  |  Branch (113:24): [True: 1, False: 0]
  |  Branch (113:40): [True: 0, False: 0]
  ------------------
  114|      1|    bool version1_0 = XMLString::equals(version, g1_0);
  115|      1|    bool version2_0 = XMLString::equals(version, g2_0);
  116|      1|    bool version3_0 = XMLString::equals(version, g3_0);
  117|       |
  118|       |    // Currently, we support only XML Level 1 version 1.0
  119|      1|    if (XMLString::compareIStringASCII(feature, XMLUni::fgXMLString) == 0
  ------------------
  |  Branch (119:9): [True: 0, False: 1]
  ------------------
  120|      1|        && (anyVersion || version1_0 || version2_0))
  ------------------
  |  Branch (120:13): [True: 0, False: 0]
  |  Branch (120:27): [True: 0, False: 0]
  |  Branch (120:41): [True: 0, False: 0]
  ------------------
  121|      0|        return true;
  122|       |
  123|      1|    if (XMLString::compareIStringASCII(feature, gCore) == 0
  ------------------
  |  Branch (123:9): [True: 1, False: 0]
  ------------------
  124|      1|        && (anyVersion || version1_0 || version2_0 || version3_0))
  ------------------
  |  Branch (124:13): [True: 1, False: 0]
  |  Branch (124:27): [True: 0, False: 0]
  |  Branch (124:41): [True: 0, False: 0]
  |  Branch (124:55): [True: 0, False: 0]
  ------------------
  125|      1|        return true;
  126|       |
  127|      0|    if (XMLString::compareIStringASCII(feature, gTrav) == 0
  ------------------
  |  Branch (127:9): [True: 0, False: 0]
  ------------------
  128|      0|        && (anyVersion || version2_0))
  ------------------
  |  Branch (128:13): [True: 0, False: 0]
  |  Branch (128:27): [True: 0, False: 0]
  ------------------
  129|      0|        return true;
  130|       |
  131|      0|    if (XMLString::compareIStringASCII(feature, gRange) == 0
  ------------------
  |  Branch (131:9): [True: 0, False: 0]
  ------------------
  132|      0|        && (anyVersion || version2_0))
  ------------------
  |  Branch (132:13): [True: 0, False: 0]
  |  Branch (132:27): [True: 0, False: 0]
  ------------------
  133|      0|        return true;
  134|       |
  135|      0|    if (XMLString::compareIStringASCII(feature, gLS) == 0
  ------------------
  |  Branch (135:9): [True: 0, False: 0]
  ------------------
  136|      0|        && (anyVersion || version3_0))
  ------------------
  |  Branch (136:13): [True: 0, False: 0]
  |  Branch (136:27): [True: 0, False: 0]
  ------------------
  137|      0|        return true;
  138|       |
  139|      0|    if (XMLString::compareIStringASCII(feature, gXPath) == 0
  ------------------
  |  Branch (139:9): [True: 0, False: 0]
  ------------------
  140|      0|        && (anyVersion || version3_0))
  ------------------
  |  Branch (140:13): [True: 0, False: 0]
  |  Branch (140:27): [True: 0, False: 0]
  ------------------
  141|      0|        return true;
  142|       |
  143|      0|    return false;
  144|      0|}
_ZN11xercesc_3_221DOMImplementationImpl14createDocumentEPNS_13MemoryManagerE:
  175|      1|{
  176|      1|        return new (manager) DOMDocumentImpl(this, manager);
  177|      1|}
_ZN11xercesc_3_217DOMImplementation17getImplementationEv:
  184|      1|{
  185|      1|    return (DOMImplementation*) DOMImplementationImpl::getDOMImplementationImpl();
  186|      1|}
_ZNK11xercesc_3_221DOMImplementationImpl20getDOMImplementationEPKDs:
  256|      1|{
  257|      1|    DOMImplementation* impl = DOMImplementation::getImplementation();
  258|       |
  259|      1|    XMLStringTokenizer tokenizer(features, XMLPlatformUtils::fgMemoryManager);
  260|      1|    const XMLCh* feature = 0;
  261|       |
  262|      2|    while (feature || tokenizer.hasMoreTokens()) {
  ------------------
  |  Branch (262:12): [True: 0, False: 2]
  |  Branch (262:23): [True: 1, False: 1]
  ------------------
  263|       |
  264|      1|        if (!feature)
  ------------------
  |  Branch (264:13): [True: 1, False: 0]
  ------------------
  265|      1|            feature = tokenizer.nextToken();
  266|       |
  267|      1|        const XMLCh* version = 0;
  268|      1|        const XMLCh* token = tokenizer.nextToken();
  269|       |
  270|      1|        if (token && XMLString::isDigit(token[0]))
  ------------------
  |  Branch (270:13): [True: 0, False: 1]
  |  Branch (270:22): [True: 0, False: 0]
  ------------------
  271|      0|            version = token;
  272|       |
  273|      1|        if (!impl->hasFeature(feature, version))
  ------------------
  |  Branch (273:13): [True: 0, False: 1]
  ------------------
  274|      0|            return 0;
  275|       |
  276|      1|        if (!version)
  ------------------
  |  Branch (276:13): [True: 1, False: 0]
  ------------------
  277|      1|            feature = token;
  278|      1|    }
  279|      1|    return impl;
  280|      1|}

_ZN11xercesc_3_221DOMImplementationImplC2Ev:
   52|      1|    DOMImplementationImpl() {};

_ZN11xercesc_3_214XMLInitializer35initializeDOMImplementationRegistryEv:
   43|      1|{
   44|      1|    gDOMImplSrcVectorMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
   45|      1|    gDOMImplSrcVector = new RefVectorOf<DOMImplementationSource>(3, false);
   46|      1|}
_ZN11xercesc_3_225DOMImplementationRegistry20getDOMImplementationEPKDs:
   60|      1|DOMImplementation *DOMImplementationRegistry::getDOMImplementation(const XMLCh* features) {
   61|       |
   62|      1|    XMLMutexLock lock(gDOMImplSrcVectorMutex);
   63|       |
   64|      1|    XMLSize_t len = gDOMImplSrcVector->size();
   65|       |
   66|       |    // Put our defined source there
   67|      1|    if (len == 0) {
  ------------------
  |  Branch (67:9): [True: 1, False: 0]
  ------------------
   68|      1|        gDOMImplSrcVector->addElement((DOMImplementationSource*)DOMImplementationImpl::getDOMImplementationImpl());
   69|       |
   70|      1|        len = gDOMImplSrcVector->size();
   71|      1|    }
   72|       |
   73|      1|    for (XMLSize_t i = len; i > 0; i--) {
  ------------------
  |  Branch (73:29): [True: 1, False: 0]
  ------------------
   74|      1|        DOMImplementationSource* source = gDOMImplSrcVector->elementAt(i-1);
   75|      1|        DOMImplementation* impl = source->getDOMImplementation(features);
   76|      1|        if (impl)
  ------------------
  |  Branch (76:13): [True: 1, False: 0]
  ------------------
   77|      1|            return impl;
   78|      1|    }
   79|       |
   80|      0|    return 0;
   81|      1|}

_ZN11xercesc_3_214HasDOMNodeImplC2Ev:
   56|      1|    HasDOMNodeImpl() {}
_ZN11xercesc_3_216HasDOMParentImplC2Ev:
  114|      1|    HasDOMParentImpl() {}

_ZN11xercesc_3_214XMLInitializer25initializeDOMNodeListImplEv:
   66|      1|{
   67|      1|    gEmptyNodeList = new DOMNodeListImpl(0);
   68|      1|}
_ZN11xercesc_3_211DOMNodeImplC2EPNS_7DOMNodeES2_:
   81|      1|{
   82|      1|    if (!fContainingNode) {
  ------------------
  |  Branch (82:9): [True: 0, False: 1]
  ------------------
   83|      0|        throw DOMException(DOMException::INVALID_STATE_ERR, 0, GetDOMNodeMemoryManager);
  ------------------
  |  |  921|      0|#define GetDOMNodeMemoryManager GET_INDIRECT_MM(this)
  |  |  ------------------
  |  |  |  |  914|      0|        (!ptr ? XMLPlatformUtils::fgMemoryManager :                              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (914:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  915|      0|        GET_OWNER_DOCUMENT(ptr) ? GET_OWNER_DOCUMENT(ptr)->getMemoryManager() : \
  |  |  |  |  ------------------
  |  |  |  |  |  |  908|      0|        ((DOMDocumentImpl*)(ptr->getOwnerDocument()))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (908:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                       GET_OWNER_DOCUMENT(ptr) ? GET_OWNER_DOCUMENT(ptr)->getMemoryManager() : \
  |  |  |  |  ------------------
  |  |  |  |  |  |  908|      0|        ((DOMDocumentImpl*)(ptr->getOwnerDocument()))
  |  |  |  |  ------------------
  |  |  |  |  916|      0|        XMLPlatformUtils::fgMemoryManager)
  |  |  ------------------
  ------------------
   84|      0|    }
   85|       |    
   86|      1|    this->flags = 0;
   87|       |    // as long as we do not have any owner, fOwnerNode is our ownerDocument
   88|      1|}

_ZN11xercesc_3_215DOMNodeListImplC2EPNS_13DOMParentNodeE:
   36|      2|{
   37|      2|}

_ZN11xercesc_3_214XMLInitializer23initializeDOMNormalizerEv:
   46|      1|{
   47|      1|    gMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgXMLErrDomain);
   48|       |
   49|      1|    if (!gMsgLoader)
  ------------------
  |  Branch (49:9): [True: 0, False: 1]
  ------------------
   50|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   51|      1|}

_ZN11xercesc_3_213DOMParentNodeC2EPNS_7DOMNodeEPNS_11DOMDocumentE:
   36|      1|{
   37|      1|    if (!fContainingNode) {
  ------------------
  |  Branch (37:9): [True: 0, False: 1]
  ------------------
   38|      0|        throw DOMException(DOMException::INVALID_STATE_ERR, 0, GetDOMNodeMemoryManager);
  ------------------
  |  |  921|      0|#define GetDOMNodeMemoryManager GET_INDIRECT_MM(this)
  |  |  ------------------
  |  |  |  |  914|      0|        (!ptr ? XMLPlatformUtils::fgMemoryManager :                              \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (914:10): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  915|      0|        GET_OWNER_DOCUMENT(ptr) ? GET_OWNER_DOCUMENT(ptr)->getMemoryManager() : \
  |  |  |  |  ------------------
  |  |  |  |  |  |  908|      0|        ((DOMDocumentImpl*)(ptr->getOwnerDocument()))
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (908:9): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |                       GET_OWNER_DOCUMENT(ptr) ? GET_OWNER_DOCUMENT(ptr)->getMemoryManager() : \
  |  |  |  |  ------------------
  |  |  |  |  |  |  908|      0|        ((DOMDocumentImpl*)(ptr->getOwnerDocument()))
  |  |  |  |  ------------------
  |  |  |  |  916|      0|        XMLPlatformUtils::fgMemoryManager)
  |  |  ------------------
  ------------------
   39|      0|    }
   40|      1|}

_ZN11xercesc_3_215DOMTypeInfoImplC2EPKDsS2_:
   46|     24|{
   47|       |    // by setting the fBitField to 0 we are also setting:
   48|       |    //  - [validity]=VALIDITY_NOTKNOWN
   49|       |    //  - [validitation attempted]=VALIDATION_NONE
   50|       |    //  - [schema specified]=false
   51|     24|}

_ZN11xercesc_3_220LocalFileInputSourceC2EPKDsS2_PNS_13MemoryManagerE:
   87|  2.23k|{
   88|       |    //
   89|       |    //  If the relative part is really relative, then weave it together
   90|       |    //  with the base path. If not, just take the relative path as the
   91|       |    //  entire path.
   92|       |    //
   93|  2.23k|    if (XMLPlatformUtils::isRelative(relativePath, manager))
  ------------------
  |  Branch (93:9): [True: 2.15k, False: 84]
  ------------------
   94|  2.15k|    {
   95|  2.15k|        XMLCh* tmpBuf = XMLPlatformUtils::weavePaths(basePath, relativePath, manager);
   96|  2.15k|        setSystemId(tmpBuf);
   97|  2.15k|        manager->deallocate(tmpBuf); //delete [] tmpBuf;
   98|  2.15k|    }
   99|     84|    else
  100|     84|    {
  101|     84|        XMLCh* tmpBuf = XMLString::replicate(relativePath, manager);
  102|     84|        XMLPlatformUtils::removeDotSlash(tmpBuf, manager);
  103|     84|        setSystemId(tmpBuf);
  104|     84|        manager->deallocate(tmpBuf);//delete [] tmpBuf;
  105|     84|    }
  106|       |
  107|  2.23k|}
_ZN11xercesc_3_220LocalFileInputSourceD2Ev:
  153|  2.23k|{
  154|  2.23k|}
_ZNK11xercesc_3_220LocalFileInputSource10makeStreamEv:
  161|  2.23k|{
  162|  2.23k|    BinFileInputStream* retStrm = new (getMemoryManager()) BinFileInputStream(getSystemId(), getMemoryManager());
  163|  2.23k|    if (!retStrm->getIsOpen())
  ------------------
  |  Branch (163:9): [True: 2.09k, False: 142]
  ------------------
  164|  2.09k|    {
  165|  2.09k|        delete retStrm;
  166|  2.09k|        return 0;
  167|  2.09k|    }
  168|    142|    return retStrm;
  169|  2.23k|}

_ZN11xercesc_3_217MemBufInputSourceC2EPKhmPKcbPNS_13MemoryManagerE:
   57|  8.51k|{
   58|  8.51k|}
_ZN11xercesc_3_217MemBufInputSourceD2Ev:
   61|  8.51k|{
   62|  8.51k|    if (fAdopted)
  ------------------
  |  Branch (62:9): [True: 0, False: 8.51k]
  ------------------
   63|      0|        delete [] (XMLByte*)fSrcBytes;
   64|  8.51k|}
_ZNK11xercesc_3_217MemBufInputSource10makeStreamEv:
   77|  8.51k|{
   78|       |    //
   79|       |    //  Create a memory input stream over our buffer. According to our
   80|       |    //  fCopyBufToStream flag, we either tell it to copy the buffer or to
   81|       |    //  just reference it.
   82|       |    //
   83|  8.51k|    return new (getMemoryManager()) BinMemInputStream
   84|  8.51k|    (
   85|  8.51k|        fSrcBytes
   86|  8.51k|        , fByteCount
   87|  8.51k|        , fCopyBufToStream ? BinMemInputStream::BufOpt_Copy
  ------------------
  |  Branch (87:11): [True: 8.51k, False: 0]
  ------------------
   88|  8.51k|                           : BinMemInputStream::BufOpt_Reference
   89|  8.51k|        , getMemoryManager()
   90|  8.51k|    );
   91|  8.51k|}

_ZN11xercesc_3_213MemoryManagerC2Ev:
  109|      1|    {
  110|      1|    }

_ZN11xercesc_3_214URLInputSourceC2ERKNS_6XMLURLEPNS_13MemoryManagerE:
   42|    150|{
   43|    150|    setSystemId(fURL.getURLText());
   44|    150|}
_ZN11xercesc_3_214URLInputSourceD2Ev:
   86|    150|{
   87|    150|}
_ZNK11xercesc_3_214URLInputSource10makeStreamEv:
   94|    150|{
   95|       |    // Ask the URL to create us an appropriate input stream
   96|    150|    return fURL.makeNewStream();
   97|    150|}

_ZN11xercesc_3_217ValidationContextD2Ev:
   51|  8.51k|    virtual ~ValidationContext(){};
_ZN11xercesc_3_217ValidationContextC2EPNS_13MemoryManagerE:
  113|  8.51k|    {
  114|  8.51k|    };

_ZN11xercesc_3_29XMLAttDefD2Ev:
  110|  9.49k|{
  111|  9.49k|    cleanUp();
  112|  9.49k|}
_ZN11xercesc_3_29XMLAttDefC2ENS0_8AttTypesENS0_11DefAttTypesEPNS_13MemoryManagerE:
  130|  9.49k|{
  131|  9.49k|}
_ZN11xercesc_3_29XMLAttDef7cleanUpEv:
  172|  9.49k|{
  173|  9.49k|    if (fEnumeration)
  ------------------
  |  Branch (173:9): [True: 6, False: 9.49k]
  ------------------
  174|      6|        fMemoryManager->deallocate(fEnumeration);
  175|       |
  176|  9.49k|    if (fValue)
  ------------------
  |  Branch (176:9): [True: 899, False: 8.59k]
  ------------------
  177|    899|        fMemoryManager->deallocate(fValue);
  178|  9.49k|}

_ZNK11xercesc_3_29XMLAttDef14getDefaultTypeEv:
  453|   297k|{
  454|   297k|    return fDefaultType;
  455|   297k|}
_ZNK11xercesc_3_29XMLAttDef14getEnumerationEv:
  458|  53.8k|{
  459|  53.8k|    return fEnumeration;
  460|  53.8k|}
_ZNK11xercesc_3_29XMLAttDef7getTypeEv:
  468|   123k|{
  469|   123k|    return fType;
  470|   123k|}
_ZNK11xercesc_3_29XMLAttDef8getValueEv:
  473|   143k|{
  474|   143k|    return fValue;
  475|   143k|}
_ZNK11xercesc_3_29XMLAttDef10isExternalEv:
  483|   107k|{
  484|   107k|    return fExternalAttribute;
  485|   107k|}
_ZNK11xercesc_3_29XMLAttDef16getMemoryManagerEv:
  488|  30.5k|{
  489|  30.5k|    return fMemoryManager;
  490|  30.5k|}
_ZN11xercesc_3_29XMLAttDef14setDefaultTypeENS0_11DefAttTypesE:
  496|  15.0k|{
  497|  15.0k|    fDefaultType = newValue;
  498|  15.0k|}
_ZN11xercesc_3_29XMLAttDef14setEnumerationEPKDs:
  501|      6|{
  502|      6|    if (fEnumeration)
  ------------------
  |  Branch (502:9): [True: 0, False: 6]
  ------------------
  503|      0|        fMemoryManager->deallocate(fEnumeration);
  504|       |
  505|      6|    fEnumeration = XMLString::replicate(newValue, fMemoryManager);
  506|      6|}
_ZN11xercesc_3_29XMLAttDef5setIdEm:
  509|  9.49k|{
  510|  9.49k|    fId = newId;
  511|  9.49k|}
_ZN11xercesc_3_29XMLAttDef7setTypeENS0_8AttTypesE:
  514|  15.1k|{
  515|  15.1k|    fType = newValue;
  516|  15.1k|}
_ZN11xercesc_3_29XMLAttDef8setValueEPKDs:
  519|  1.55k|{
  520|  1.55k|    if (fValue)
  ------------------
  |  Branch (520:9): [True: 657, False: 899]
  ------------------
  521|    657|       fMemoryManager->deallocate(fValue);
  522|       |
  523|  1.55k|    fValue = XMLString::replicate(newValue, fMemoryManager);
  524|  1.55k|}
_ZN11xercesc_3_29XMLAttDef25setExternalAttDeclarationEb:
  533|  9.22k|{
  534|  9.22k|    fExternalAttribute = aValue;
  535|  9.22k|}

_ZNK11xercesc_3_213XMLAttDefList16getMemoryManagerEv:
  149|  80.3k|{
  150|  80.3k|    return fMemoryManager;
  151|  80.3k|}
_ZN11xercesc_3_213XMLAttDefListC2EPNS_13MemoryManagerE:
  166|  39.0k|{
  167|  39.0k|}

_ZN11xercesc_3_27XMLAttrC2EjPKDsS2_S2_NS_9XMLAttDef8AttTypesEbPNS_13MemoryManagerEPNS_17DatatypeValidatorEb:
   65|  3.11k|{
   66|  3.11k|    CleanupType cleanup(this, &XMLAttr::cleanUp);
   67|       |
   68|  3.11k|    try
   69|  3.11k|    {
   70|       |        //
   71|       |        //  Just call the local setters to set up everything. Too much
   72|       |        //  work is required to replicate that functionality here.
   73|       |        //
   74|  3.11k|        fAttName = new (fMemoryManager) QName(attrPrefix, attrName, uriId, fMemoryManager);
   75|  3.11k|        setValue(attrValue);
   76|  3.11k|    }
   77|  3.11k|    catch(const OutOfMemoryException&)
   78|  3.11k|    {
   79|      0|        cleanup.release();
   80|       |
   81|      0|        throw;
   82|      0|    }
   83|       |
   84|  3.11k|    cleanup.release();
   85|  3.11k|}
_ZN11xercesc_3_27XMLAttr8setValueEPKDs:
  150|   991k|{
  151|   991k|    const XMLSize_t newLen = XMLString::stringLen(newValue);
  152|   991k|    if (!fValueBufSz || (newLen > fValueBufSz))
  ------------------
  |  Branch (152:9): [True: 3.11k, False: 987k]
  |  Branch (152:25): [True: 1.35k, False: 986k]
  ------------------
  153|  4.46k|    {
  154|  4.46k|        fMemoryManager->deallocate(fValue); //delete [] fValue;
  155|  4.46k|        fValue = 0;
  156|  4.46k|        fValueBufSz = newLen + 8;
  157|  4.46k|        fValue = (XMLCh*) fMemoryManager->allocate((fValueBufSz+1) * sizeof(XMLCh)); //new XMLCh[fValueBufSz + 1];
  158|  4.46k|    }
  159|   991k|    XMLString::moveChars(fValue, newValue, newLen + 1);
  160|   991k|}
_ZN11xercesc_3_27XMLAttr7cleanUpEv:
  167|  3.11k|{
  168|  3.11k|    delete fAttName;
  169|  3.11k|    fMemoryManager->deallocate(fValue); //delete [] fValue;
  170|  3.11k|}

_ZNK11xercesc_3_27XMLAttr7getNameEv:
  426|   473k|{
  427|   473k|    return fAttName->getLocalPart();
  428|   473k|}
_ZN11xercesc_3_27XMLAttr3setEjPKDsS2_S2_NS_9XMLAttDef8AttTypesEPNS_17DatatypeValidatorEb:
  465|   514k|{
  466|       |    // Set the name info and the value via their respective calls
  467|   514k|    fAttName->setName(attrPrefix, attrName, uriId);
  468|   514k|    setValue(attrValue);
  469|       |
  470|       |    // And store the type
  471|   514k|    fType = type;
  472|   514k|}
_ZN11xercesc_3_27XMLAttr12setSpecifiedEb:
  495|   514k|{
  496|   514k|    fSpecified = newValue;
  497|   514k|}
_ZN11xercesc_3_27XMLAttrD2Ev:
  412|  3.11k|{
  413|  3.11k|    cleanUp();
  414|  3.11k|}

_ZN11xercesc_3_29XMLBuffer14ensureCapacityEm:
   37|  4.36k|{    
   38|       |    // If we can't handle it, try doubling the buffer size.
   39|  4.36k|    XMLSize_t newCap = (fIndex + extraNeeded) * 2;
   40|       |
   41|       |    // If a maximum size is set, and double the current buffer size exceeds that
   42|       |    // maximum, first check if the maximum size will accomodate the extra needed.
   43|  4.36k|    if (fFullHandler && (newCap > fFullSize))
  ------------------
  |  Branch (43:9): [True: 92, False: 4.27k]
  |  Branch (43:25): [True: 1, False: 91]
  ------------------
   44|      1|    {
   45|       |        // If the maximum buffer size accomodates the extra needed, resize to
   46|       |        // the maximum
   47|      1|        if (fIndex + extraNeeded <= fFullSize) 
  ------------------
  |  Branch (47:13): [True: 1, False: 0]
  ------------------
   48|      1|        {
   49|      1|            newCap = fFullSize;
   50|      1|        }
   51|       |
   52|       |        // Otherwise, allow the registered full-handler to try to empty the buffer.
   53|       |        // If it claims success, and we can accommodate the extra needed in the buffer
   54|       |        // to be expanded, resize to the maximum
   55|       |        // Note the order of evaluation: bufferFull() has the intentional side-effect
   56|       |        // of modifying fIndex.
   57|      0|        else if (fFullHandler->bufferFull(*this) && (fIndex + extraNeeded <= fFullSize))
  ------------------
  |  Branch (57:18): [True: 0, False: 0]
  |  Branch (57:53): [True: 0, False: 0]
  ------------------
   58|      0|        {
   59|      0|            newCap = fFullSize;
   60|      0|        }
   61|       |
   62|       |        // Finally, if the full-handler failed, or the buffer (of maximum size) 
   63|       |        // still can't accomodate the extra needed, we must fail.
   64|      0|        else
   65|      0|            ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Array_BadNewSize, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   66|      1|    }
   67|       |
   68|       |    // Note the previous if block can modify newCap, so we may not need to allocate
   69|       |    // at all.
   70|  4.36k|    if (newCap > fCapacity)
  ------------------
  |  Branch (70:9): [True: 4.36k, False: 0]
  ------------------
   71|  4.36k|    {
   72|       |        // Allocate new buffer
   73|  4.36k|        XMLCh* newBuf = (XMLCh*) fMemoryManager->allocate((newCap+1) * sizeof(XMLCh)); //new XMLCh[newCap+1];
   74|       | 
   75|       |        // Copy over the old stuff
   76|  4.36k|        memcpy(newBuf, fBuffer, fIndex * sizeof(XMLCh));
   77|       |
   78|       |        // Clean up old buffer and store new stuff
   79|  4.36k|        fMemoryManager->deallocate(fBuffer); //delete [] fBuffer;
   80|  4.36k|        fBuffer = newBuf;
   81|  4.36k|        fCapacity = newCap;
   82|  4.36k|    }
   83|  4.36k|}

_ZN11xercesc_3_29XMLBufferC2EmPNS_13MemoryManagerE:
   63|   144k|    {
   64|       |        // Buffer is one larger than capacity, to allow for zero term
   65|   144k|        fBuffer = (XMLCh*) manager->allocate((capacity+1) * sizeof(XMLCh)); //new XMLCh[fCapacity+1];
   66|       |
   67|       |        // Keep it null terminated
   68|   144k|        fBuffer[0] = XMLCh(0);
   69|   144k|    }
_ZN11xercesc_3_29XMLBufferD2Ev:
   75|   144k|    {
   76|   144k|        fMemoryManager->deallocate(fBuffer); //delete [] fBuffer;
   77|   144k|    }
_ZN11xercesc_3_29XMLBuffer14setFullHandlerEPNS_20XMLBufferFullHandlerEm:
   84|  8.51k|    {
   85|  8.51k|        if (handler && fullSize) {
  ------------------
  |  Branch (85:13): [True: 8.51k, False: 0]
  |  Branch (85:24): [True: 8.51k, False: 0]
  ------------------
   86|  8.51k|            fFullHandler = handler;
   87|  8.51k|            fFullSize = fullSize;
   88|       |
   89|       |            // Need to consider the case that the fullsize is less than the current capacity.
   90|       |            // For example, say fullSize = 100 and fCapacity is 1023 (the default).
   91|       |            // If the fIndex is less than the fullSize, then no problem.  We can just carry
   92|       |            // on by resetting fCapacity to fullsize and proceed business as usual.
   93|       |            // If the fIndex is already bigger than the fullSize then we call ensureCapacity
   94|       |            // to see if it can handle emptying the current buffer (it will throw an
   95|       |            // exception if it can't).
   96|  8.51k|            if (fullSize < fCapacity) {
  ------------------
  |  Branch (96:17): [True: 0, False: 8.51k]
  ------------------
   97|      0|                fCapacity = fullSize;
   98|      0|                if (fIndex >= fullSize) {
  ------------------
  |  Branch (98:21): [True: 0, False: 0]
  ------------------
   99|      0|                    ensureCapacity(0);
  100|      0|                }
  101|      0|            }
  102|  8.51k|        }
  103|      0|        else {
  104|       |            // reset fFullHandler to zero because setFullHandler had bad input
  105|      0|            fFullHandler = 0;
  106|      0|        }
  107|  8.51k|    }
_ZN11xercesc_3_29XMLBuffer6appendEDs:
  113|   145M|    {
  114|       |        // Put in char and bump the index
  115|   145M|        if (fIndex == fCapacity)
  ------------------
  |  Branch (115:13): [True: 3.10k, False: 145M]
  ------------------
  116|  3.10k|            ensureCapacity(1);
  117|   145M|        fBuffer[fIndex++] = toAppend;
  118|   145M|    }
_ZN11xercesc_3_29XMLBuffer6appendEPKDsm:
  121|  3.05M|    {
  122|  3.05M|        if (count) {
  ------------------
  |  Branch (122:13): [True: 3.05M, False: 0]
  ------------------
  123|  3.05M|            if (fIndex + count >= fCapacity) {
  ------------------
  |  Branch (123:17): [True: 526, False: 3.05M]
  ------------------
  124|    526|                ensureCapacity(count);
  125|    526|            }
  126|  3.05M|            memcpy(&fBuffer[fIndex], chars, count * sizeof(XMLCh));
  127|  3.05M|            fIndex += count;
  128|  3.05M|        }
  129|      0|        else {
  130|      0|            append(chars);
  131|      0|        }
  132|  3.05M|    }
_ZN11xercesc_3_29XMLBuffer6appendEPKDs:
  135|  1.24M|    {
  136|  1.24M|        if (chars != 0 && *chars != 0) {
  ------------------
  |  Branch (136:13): [True: 1.24M, False: 0]
  |  Branch (136:27): [True: 1.11M, False: 131k]
  ------------------
  137|       |            // get length of chars
  138|  1.11M|            XMLSize_t count = 0;
  139|  15.1M|            for (; *(chars+count); count++ ) /*noop*/;
  ------------------
  |  Branch (139:20): [True: 14.0M, False: 1.11M]
  ------------------
  140|       |
  141|  1.11M|            if (fIndex + count >= fCapacity) {
  ------------------
  |  Branch (141:17): [True: 738, False: 1.11M]
  ------------------
  142|    738|                ensureCapacity(count);
  143|    738|            }
  144|  1.11M|            memcpy(&fBuffer[fIndex], chars, count * sizeof(XMLCh));
  145|  1.11M|            fIndex += count;
  146|  1.11M|        }
  147|  1.24M|    }
_ZN11xercesc_3_29XMLBuffer3setEPKDs:
  156|  2.39k|    {
  157|  2.39k|        fIndex = 0;
  158|  2.39k|        if (chars != 0 && *chars != 0)
  ------------------
  |  Branch (158:13): [True: 2.39k, False: 0]
  |  Branch (158:27): [True: 2.39k, False: 1]
  ------------------
  159|  2.39k|            append(chars);
  160|  2.39k|    }
_ZN11xercesc_3_29XMLBuffer12getRawBufferEv:
  169|  4.70M|    {
  170|  4.70M|        fBuffer[fIndex] = 0;
  171|  4.70M|        return fBuffer;
  172|  4.70M|    }
_ZN11xercesc_3_29XMLBuffer5resetEv:
  175|  4.73M|    {
  176|  4.73M|        fIndex = 0;
  177|  4.73M|    }
_ZNK11xercesc_3_29XMLBuffer8getInUseEv:
  183|   656k|    {
  184|   656k|        return fUsed;
  185|   656k|    }
_ZNK11xercesc_3_29XMLBuffer6getLenEv:
  188|  1.08M|    {
  189|  1.08M|        return fIndex;
  190|  1.08M|    }
_ZNK11xercesc_3_29XMLBuffer7isEmptyEv:
  193|  3.32M|    {
  194|  3.32M|        return (fIndex == 0);
  195|  3.32M|    }
_ZN11xercesc_3_29XMLBuffer8setInUseEb:
  201|   383k|    {
  202|   383k|        fUsed = newValue;
  203|   383k|    }
_ZN11xercesc_3_220XMLBufferFullHandlerD2Ev:
  267|  8.51k|    virtual ~XMLBufferFullHandler() {}

_ZN11xercesc_3_212XMLBufferMgrC2EPNS_13MemoryManagerE:
   40|  8.51k|{
   41|       |    // Allocate the buffer list and zero it out
   42|  8.51k|    fBufList = (XMLBuffer**) fMemoryManager->allocate(fBufCount * sizeof(XMLBuffer*)); // new XMLBuffer*[fBufCount];
   43|   281k|    for (XMLSize_t index = 0; index < fBufCount; index++)
  ------------------
  |  Branch (43:31): [True: 272k, False: 8.51k]
  ------------------
   44|   272k|        fBufList[index] = 0;
   45|  8.51k|}
_ZN11xercesc_3_212XMLBufferMgrD2Ev:
   48|  8.51k|{
   49|       |    // Delete any buffers that got allocated
   50|   281k|    for (XMLSize_t index = 0; index < fBufCount; index++)
  ------------------
  |  Branch (50:31): [True: 272k, False: 8.51k]
  ------------------
   51|   272k|        delete fBufList[index];
   52|       |
   53|       |    // And then the buffer list
   54|  8.51k|    fMemoryManager->deallocate(fBufList); //delete [] fBufList;
   55|  8.51k|}
_ZN11xercesc_3_212XMLBufferMgr11bidOnBufferEv:
   62|   191k|{
   63|       |    //
   64|       |    //  Look for a buffer that is not in use. If we hit a null entry, then
   65|       |    //  we have to add one.
   66|       |    //
   67|   707k|    for (XMLSize_t index = 0; index < fBufCount; index++)
  ------------------
  |  Branch (67:31): [True: 707k, False: 0]
  ------------------
   68|   707k|    {
   69|       |        // No more buffers available, so create one and take it
   70|   707k|        if (!fBufList[index])
  ------------------
  |  Branch (70:13): [True: 51.4k, False: 656k]
  ------------------
   71|  51.4k|        {
   72|  51.4k|            fBufList[index] = new (fMemoryManager) XMLBuffer(1023, fMemoryManager);
   73|  51.4k|            fBufList[index]->setInUse(true);
   74|  51.4k|            return *fBufList[index];
   75|  51.4k|        }
   76|       |
   77|       |        //
   78|       |        //  There's one here, so see if its use. If not, mark it, reset it,
   79|       |        //  and take it
   80|       |        //
   81|   656k|        if (!fBufList[index]->getInUse())
  ------------------
  |  Branch (81:13): [True: 140k, False: 516k]
  ------------------
   82|   140k|        {
   83|   140k|            fBufList[index]->reset();
   84|   140k|            fBufList[index]->setInUse(true);
   85|   140k|            return *(fBufList[index]);
   86|   140k|        }
   87|   656k|    }
   88|       |
   89|       |    // We did not find one, so freak out
   90|   191k|    ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::BufMgr_NoMoreBuffers, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   91|       |
   92|       |    // NOTE: Dummy return to make some compilers happy. Never really gets called!
   93|      0|    return *fBufList[0];
   94|   191k|}
_ZN11xercesc_3_212XMLBufferMgr13releaseBufferERNS_9XMLBufferE:
   98|   191k|{
   99|       |    // Look for this buffer in the list
  100|   707k|    for (XMLSize_t index = 0; index < fBufCount; index++)
  ------------------
  |  Branch (100:31): [True: 707k, False: 0]
  ------------------
  101|   707k|    {
  102|   707k|        if (fBufList[index] == &toRelease)
  ------------------
  |  Branch (102:13): [True: 191k, False: 516k]
  ------------------
  103|   191k|        {
  104|       |            // Unmark it
  105|   191k|            toRelease.setInUse(false);
  106|   191k|            return;
  107|   191k|        }
  108|   707k|    }
  109|       |
  110|       |    // It was not a legal buffer
  111|      0|    ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::BufMgr_BufferNotInPool, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|   191k|}

_ZN11xercesc_3_29XMLBufBidC2EPNS_12XMLBufferMgrE:
  123|   191k|    {
  124|   191k|    }
_ZN11xercesc_3_29XMLBufBidD2Ev:
  127|   191k|    {
  128|   191k|        fMgr->releaseBuffer(fBuffer);
  129|   191k|    }
_ZN11xercesc_3_29XMLBufBid6appendEDs:
  137|  21.6M|    {
  138|  21.6M|        fBuffer.append(toAppend);
  139|  21.6M|    }
_ZN11xercesc_3_29XMLBufBid9getBufferEv:
  152|   156k|    {
  153|   156k|        return fBuffer;
  154|   156k|    }
_ZN11xercesc_3_29XMLBufBid12getRawBufferEv:
  163|   154k|    {
  164|   154k|        fBuffer.fBuffer[fBuffer.fIndex] = 0;
  165|   154k|        return fBuffer.fBuffer;
  166|   154k|    }
_ZNK11xercesc_3_29XMLBufBid6getLenEv:
  169|  14.5k|    {
  170|  14.5k|        return fBuffer.fIndex;
  171|  14.5k|    }
_ZNK11xercesc_3_29XMLBufBid7isEmptyEv:
  174|     42|    {
  175|     42|        return (fBuffer.fIndex == 0);
  176|     42|    }

_ZN11xercesc_3_215XMLContentModelD2Ev:
   74|  1.59k|    {
   75|  1.59k|    }
_ZN11xercesc_3_215XMLContentModelC2Ev:
  131|  1.59k|    {
  132|  1.59k|    }

_ZN11xercesc_3_217XMLDTDDescriptionD2Ev:
   31|  17.0k|{
   32|  17.0k|}
_ZN11xercesc_3_217XMLDTDDescriptionC2EPNS_13MemoryManagerE:
   36|  17.0k|{
   37|  17.0k|}

_ZN11xercesc_3_218XMLDocumentHandlerD2Ev:
   51|  8.51k|    {
   52|  8.51k|    }
_ZN11xercesc_3_218XMLDocumentHandlerC2Ev:
  269|  8.51k|    {
  270|  8.51k|    }

_ZN11xercesc_3_214XMLElementDeclD2Ev:
   52|  52.7k|{
   53|  52.7k|    delete fElementName;
   54|  52.7k|}
_ZN11xercesc_3_214XMLElementDecl14setElementNameEPKDsi:
   73|  54.7k|{
   74|  54.7k|    if (fElementName)
  ------------------
  |  Branch (74:9): [True: 1.96k, False: 52.7k]
  ------------------
   75|  1.96k|        fElementName->setName(rawName, uriId);
   76|  52.7k|    else
   77|  52.7k|        fElementName = new (fMemoryManager) QName(rawName, uriId, fMemoryManager);
   78|  54.7k|}
_ZN11xercesc_3_214XMLElementDeclC2EPNS_13MemoryManagerE:
   99|  52.7k|{
  100|  52.7k|}

_ZN11xercesc_3_214XMLElementDecl14getElementNameEv:
  494|  2.06M|{
  495|  2.06M|    return fElementName;
  496|  2.06M|}
_ZNK11xercesc_3_214XMLElementDecl11getFullNameEv:
  499|  1.28M|{
  500|  1.28M|    return fElementName->getRawName();
  501|  1.28M|}
_ZNK11xercesc_3_214XMLElementDecl15getCreateReasonEv:
  504|  38.2k|{
  505|  38.2k|    return fCreateReason;
  506|  38.2k|}
_ZNK11xercesc_3_214XMLElementDecl5getIdEv:
  509|  9.22k|{
  510|  9.22k|    return fId;
  511|  9.22k|}
_ZNK11xercesc_3_214XMLElementDecl10isDeclaredEv:
  514|   554k|{
  515|   554k|    return (fCreateReason == Declared);
  516|   554k|}
_ZNK11xercesc_3_214XMLElementDecl10isExternalEv:
  520|   309k|{
  521|   309k|    return fExternalElement;
  522|   309k|}
_ZNK11xercesc_3_214XMLElementDecl16getMemoryManagerEv:
  525|   214k|{
  526|   214k|    return fMemoryManager;
  527|   214k|}
_ZN11xercesc_3_214XMLElementDecl15setCreateReasonENS0_13CreateReasonsE:
  535|  54.7k|{
  536|  54.7k|    fCreateReason = newReason;
  537|  54.7k|}
_ZN11xercesc_3_214XMLElementDecl5setIdEm:
  540|  58.2k|{
  541|  58.2k|    fId = newId;
  542|  58.2k|}
_ZN11xercesc_3_214XMLElementDecl26setExternalElemDeclarationEb:
  546|  49.1k|{
  547|  49.1k|    fExternalElement = aValue;
  548|  49.1k|}

_ZN11xercesc_3_213XMLEntityDeclC2EPNS_13MemoryManagerE:
   47|    259|{
   48|    259|}
_ZN11xercesc_3_213XMLEntityDeclC2EPKDsPNS_13MemoryManagerE:
   63|  2.88k|{
   64|  2.88k|    fName = XMLString::replicate(entName, fMemoryManager);
   65|  2.88k|}
_ZN11xercesc_3_213XMLEntityDeclC2EPKDsDsPNS_13MemoryManagerE:
  113|      5|{
  114|      5|    CleanupType cleanup(this, &XMLEntityDecl::cleanUp);
  115|       |
  116|      5|    try
  117|      5|    {
  118|      5|        XMLCh dummy[2] = { chNull, chNull };
  119|      5|        dummy[0] = value;
  120|      5|        fValue = XMLString::replicate(dummy, fMemoryManager);
  121|      5|        fName = XMLString::replicate(entName, fMemoryManager);
  122|      5|    }
  123|      5|    catch(const OutOfMemoryException&)
  124|      5|    {
  125|      0|        cleanup.release();
  126|       |
  127|      0|        throw;
  128|      0|    }
  129|       |
  130|      5|    cleanup.release();
  131|      5|}
_ZN11xercesc_3_213XMLEntityDeclD2Ev:
  134|  3.14k|{
  135|  3.14k|    cleanUp();
  136|  3.14k|}
_ZN11xercesc_3_213XMLEntityDecl7setNameEPKDs:
  143|  4.33k|{
  144|       |    // Clean up the current name stuff
  145|  4.33k|    if (fName)
  ------------------
  |  Branch (145:9): [True: 4.08k, False: 259]
  ------------------
  146|  4.08k|       fMemoryManager->deallocate(fName);
  147|       |
  148|  4.33k|    fName = XMLString::replicate(entName, fMemoryManager);
  149|  4.33k|}
_ZN11xercesc_3_213XMLEntityDecl7cleanUpEv:
  156|  3.14k|{
  157|  3.14k|    fMemoryManager->deallocate(fName);
  158|  3.14k|    fMemoryManager->deallocate(fNotationName);
  159|  3.14k|    fMemoryManager->deallocate(fValue);
  160|  3.14k|    fMemoryManager->deallocate(fPublicId);
  161|  3.14k|    fMemoryManager->deallocate(fSystemId);
  162|  3.14k|    fMemoryManager->deallocate(fBaseURI);
  163|  3.14k|}

_ZNK11xercesc_3_213XMLEntityDecl7getNameEv:
  397|  34.9k|{
  398|  34.9k|    return fName;
  399|  34.9k|}
_ZNK11xercesc_3_213XMLEntityDecl15getNotationNameEv:
  402|  1.55k|{
  403|  1.55k|    return fNotationName;
  404|  1.55k|}
_ZNK11xercesc_3_213XMLEntityDecl11getPublicIdEv:
  407|    392|{
  408|    392|    return fPublicId;
  409|    392|}
_ZNK11xercesc_3_213XMLEntityDecl11getSystemIdEv:
  412|    392|{
  413|    392|    return fSystemId;
  414|    392|}
_ZNK11xercesc_3_213XMLEntityDecl10getBaseURIEv:
  417|    392|{
  418|    392|    return fBaseURI;
  419|    392|}
_ZNK11xercesc_3_213XMLEntityDecl8getValueEv:
  422|  17.7k|{
  423|  17.7k|    return fValue;
  424|  17.7k|}
_ZNK11xercesc_3_213XMLEntityDecl11getValueLenEv:
  427|  16.8k|{
  428|  16.8k|    return fValueLen;
  429|  16.8k|}
_ZNK11xercesc_3_213XMLEntityDecl10isExternalEv:
  432|  17.5k|{
  433|  17.5k|    return fIsExternal;
  434|  17.5k|}
_ZNK11xercesc_3_213XMLEntityDecl10isUnparsedEv:
  437|    887|{
  438|       |    // If it has a notation, its unparsed
  439|    887|    return (fNotationName != 0);
  440|    887|}
_ZN11xercesc_3_213XMLEntityDecl5setIdEm:
  451|  2.89k|{
  452|  2.89k|    fId = newId;
  453|  2.89k|}
_ZN11xercesc_3_213XMLEntityDecl13setIsExternalEb:
  456|  2.39k|{
  457|  2.39k|    fIsExternal = value;
  458|  2.39k|}
_ZN11xercesc_3_213XMLEntityDecl15setNotationNameEPKDs:
  461|    426|{
  462|    426|    if (fNotationName)
  ------------------
  |  Branch (462:9): [True: 332, False: 94]
  ------------------
  463|    332|        fMemoryManager->deallocate(fNotationName);
  464|       |
  465|    426|    fNotationName = XMLString::replicate(newName, fMemoryManager);
  466|    426|}
_ZN11xercesc_3_213XMLEntityDecl11setPublicIdEPKDs:
  469|  2.39k|{
  470|  2.39k|    if (fPublicId)
  ------------------
  |  Branch (470:9): [True: 469, False: 1.92k]
  ------------------
  471|    469|        fMemoryManager->deallocate(fPublicId);
  472|       |
  473|  2.39k|    fPublicId = XMLString::replicate(newId, fMemoryManager);
  474|  2.39k|}
_ZN11xercesc_3_213XMLEntityDecl11setSystemIdEPKDs:
  477|  2.39k|{
  478|  2.39k|    if (fSystemId)
  ------------------
  |  Branch (478:9): [True: 1.21k, False: 1.18k]
  ------------------
  479|  1.21k|        fMemoryManager->deallocate(fSystemId);
  480|       |
  481|  2.39k|    fSystemId = XMLString::replicate(newId, fMemoryManager);
  482|  2.39k|}
_ZN11xercesc_3_213XMLEntityDecl10setBaseURIEPKDs:
  485|  2.39k|{
  486|  2.39k|    if (fBaseURI)
  ------------------
  |  Branch (486:9): [True: 1.44k, False: 956]
  ------------------
  487|  1.44k|        fMemoryManager->deallocate(fBaseURI);
  488|       |
  489|  2.39k|    fBaseURI = XMLString::replicate(newId, fMemoryManager);
  490|  2.39k|}
_ZN11xercesc_3_213XMLEntityDecl8setValueEPKDs:
  493|  4.31k|{
  494|  4.31k|    if (fValue)
  ------------------
  |  Branch (494:9): [True: 2.56k, False: 1.75k]
  ------------------
  495|  2.56k|        fMemoryManager->deallocate(fValue);
  496|       |
  497|  4.31k|    fValue = XMLString::replicate(newValue, fMemoryManager);
  498|  4.31k|    fValueLen = XMLString::stringLen(newValue);
  499|  4.31k|}
_ZNK11xercesc_3_213XMLEntityDecl6getKeyEv:
  506|  5.78k|{
  507|  5.78k|    return fName;
  508|  5.78k|}

_ZN11xercesc_3_216XMLEntityHandlerD2Ev:
   57|  8.51k|    {
   58|  8.51k|    }
_ZN11xercesc_3_216XMLEntityHandlerC2Ev:
  141|  8.51k|    {
  142|  8.51k|    }

_ZN11xercesc_3_27XMLErrs7isFatalENS0_5CodesE:
  308|  47.5k|    {
  309|  47.5k|        return ((toCheck >= F_LowBounds) && (toCheck <= F_HighBounds));
  ------------------
  |  Branch (309:17): [True: 8.24k, False: 39.3k]
  |  Branch (309:45): [True: 8.24k, False: 0]
  ------------------
  310|  47.5k|    }
_ZN11xercesc_3_27XMLErrs9errorTypeENS0_5CodesE:
  323|  47.5k|    {
  324|  47.5k|       if ((toCheck >= W_LowBounds) && (toCheck <= W_HighBounds))
  ------------------
  |  Branch (324:12): [True: 47.5k, False: 0]
  |  Branch (324:40): [True: 39.3k, False: 8.24k]
  ------------------
  325|  39.3k|           return XMLErrorReporter::ErrType_Warning;
  326|  8.24k|       else if ((toCheck >= F_LowBounds) && (toCheck <= F_HighBounds))
  ------------------
  |  Branch (326:17): [True: 8.24k, False: 0]
  |  Branch (326:45): [True: 8.24k, False: 0]
  ------------------
  327|  8.24k|            return XMLErrorReporter::ErrType_Fatal;
  328|      0|       else if ((toCheck >= E_LowBounds) && (toCheck <= E_HighBounds))
  ------------------
  |  Branch (328:17): [True: 0, False: 0]
  |  Branch (328:45): [True: 0, False: 0]
  ------------------
  329|      0|            return XMLErrorReporter::ErrType_Error;
  330|      0|       return XMLErrorReporter::ErrTypes_Unknown;
  331|  47.5k|    }

_ZN11xercesc_3_216XMLErrorReporterD2Ev:
   69|  8.51k|    {
   70|  8.51k|    }
_ZN11xercesc_3_216XMLErrorReporterC2Ev:
  148|  8.51k|    {
  149|  8.51k|    }

_ZN11xercesc_3_221XMLGrammarDescriptionD2Ev:
   31|  17.0k|{
   32|  17.0k|}
_ZN11xercesc_3_221XMLGrammarDescriptionC2EPNS_13MemoryManagerE:
   36|  17.0k|{
   37|  17.0k|}

_ZNK11xercesc_3_221XMLGrammarDescription16getMemoryManagerEv:
   99|  17.0k|{
  100|  17.0k|    return fMemMgr;
  101|  17.0k|}

_ZN11xercesc_3_214XMLGrammarPoolD2Ev:
   55|  8.51k|    virtual ~XMLGrammarPool(){};
_ZN11xercesc_3_214XMLGrammarPool16getMemoryManagerEv:
  201|  8.51k|    {
  202|  8.51k|        return fMemMgr;
  203|  8.51k|    }
_ZN11xercesc_3_214XMLGrammarPoolC2EPNS_13MemoryManagerE:
  294|  8.51k|    {
  295|  8.51k|    };

_ZN11xercesc_3_218XMLGrammarPoolImplD2Ev:
   51|  8.51k|{
   52|  8.51k|    delete fGrammarRegistry;
   53|  8.51k|    delete fStringPool;
   54|  8.51k|    if(fSynchronizedStringPool)
  ------------------
  |  Branch (54:8): [True: 0, False: 8.51k]
  ------------------
   55|      0|        delete fSynchronizedStringPool;
   56|  8.51k|    if(fXSModel)
  ------------------
  |  Branch (56:8): [True: 0, False: 8.51k]
  ------------------
   57|      0|        delete fXSModel;
   58|  8.51k|}
_ZN11xercesc_3_218XMLGrammarPoolImplC2EPNS_13MemoryManagerE:
   68|  8.51k|{
   69|  8.51k|    fGrammarRegistry = new (memMgr) RefHashTableOf<Grammar>(29, true, memMgr);
   70|  8.51k|    fStringPool = new (memMgr) XMLStringPool(109, memMgr);
   71|  8.51k|}
_ZN11xercesc_3_218XMLGrammarPoolImpl16getURIStringPoolEv:
  219|  8.51k|{
  220|  8.51k|    if(fLocked)
  ------------------
  |  Branch (220:8): [True: 0, False: 8.51k]
  ------------------
  221|      0|        return fSynchronizedStringPool;
  222|  8.51k|    return fStringPool;
  223|  8.51k|}

_ZN11xercesc_3_215XMLNotationDeclC2EPKDsS2_S2_S2_PNS_13MemoryManagerE:
   60|  1.86k|{
   61|  1.86k|    CleanupType cleanup(this, &XMLNotationDecl::cleanUp);
   62|       |
   63|  1.86k|    try
   64|  1.86k|    {
   65|  1.86k|        fName = XMLString::replicate(notName, fMemoryManager);
   66|  1.86k|        fPublicId = XMLString::replicate(pubId, fMemoryManager);
   67|  1.86k|        fSystemId = XMLString::replicate(sysId, fMemoryManager);
   68|  1.86k|        fBaseURI  = XMLString::replicate(baseURI, fMemoryManager);
   69|  1.86k|    }
   70|  1.86k|    catch(const OutOfMemoryException&)
   71|  1.86k|    {
   72|      0|        cleanup.release();
   73|       |
   74|      0|        throw;
   75|      0|    }
   76|       |
   77|  1.86k|    cleanup.release();
   78|  1.86k|}
_ZN11xercesc_3_215XMLNotationDeclD2Ev:
   81|  1.86k|{
   82|  1.86k|    cleanUp();
   83|  1.86k|}
_ZN11xercesc_3_215XMLNotationDecl7cleanUpEv:
  104|  1.86k|{
  105|  1.86k|    fMemoryManager->deallocate(fName);
  106|  1.86k|    fMemoryManager->deallocate(fPublicId);
  107|  1.86k|    fMemoryManager->deallocate(fSystemId);
  108|  1.86k|    fMemoryManager->deallocate(fBaseURI);
  109|  1.86k|}

_ZN11xercesc_3_215XMLNotationDecl5setIdEm:
  187|  1.86k|{
  188|  1.86k|    fId = newId;
  189|  1.86k|}
_ZNK11xercesc_3_215XMLNotationDecl6getKeyEv:
  225|  3.72k|{
  226|  3.72k|    return fName;
  227|  3.72k|}

_ZN11xercesc_3_213XMLRecognizer18basicEncodingProbeEPKhm:
   91|  8.51k|{
   92|       |    //
   93|       |    //  As an optimization to check the 90% case, check first for the ASCII
   94|       |    //  sequence '<?xml', which means its either US-ASCII, UTF-8, or some
   95|       |    //  other encoding that we don't do manually but which happens to share
   96|       |    //  the US-ASCII code points for these characters. So just return UTF-8
   97|       |    //  to get us through the first line.
   98|       |    //
   99|  8.51k|    if (rawByteCount >= fgASCIIPreLen)
  ------------------
  |  Branch (99:9): [True: 8.51k, False: 0]
  ------------------
  100|  8.51k|    {
  101|  8.51k|        if (!memcmp(rawBuffer, fgASCIIPre, fgASCIIPreLen))
  ------------------
  |  Branch (101:13): [True: 8.51k, False: 0]
  ------------------
  102|  8.51k|            return UTF_8;
  103|  8.51k|    }
  104|       |
  105|       |    //
  106|       |    //  If the count of raw bytes is less than 2, it cannot be anything
  107|       |    //  we understand, so return UTF-8 as a fallback.
  108|       |    //
  109|      0|    if (rawByteCount < 2)
  ------------------
  |  Branch (109:9): [True: 0, False: 0]
  ------------------
  110|      0|        return UTF_8;
  111|       |         
  112|       |    //  
  113|       |    //  We have two to four bytes, so lets check for a UTF-16 BOM. That
  114|       |    //  is quick to check and enough to identify two major encodings.   
  115|       |    // 
  116|       |
  117|      0|    if (rawByteCount < 4)
  ------------------
  |  Branch (117:9): [True: 0, False: 0]
  ------------------
  118|      0|    {
  119|      0|        if ((rawBuffer[0] == 0xFE) && (rawBuffer[1] == 0xFF))
  ------------------
  |  Branch (119:13): [True: 0, False: 0]
  |  Branch (119:39): [True: 0, False: 0]
  ------------------
  120|      0|            return UTF_16B;
  121|      0|        else if ((rawBuffer[0] == 0xFF) && (rawBuffer[1] == 0xFE))
  ------------------
  |  Branch (121:18): [True: 0, False: 0]
  |  Branch (121:44): [True: 0, False: 0]
  ------------------
  122|      0|            return UTF_16L;
  123|      0|        else 
  124|      0|            return UTF_8;
  125|      0|    }
  126|       |
  127|       |    /***
  128|       |     *    F.1 Detection Without External Encoding Information
  129|       |     *
  130|       |     *    Because each XML entity not accompanied by external encoding information and 
  131|       |     *    not in UTF-8 or UTF-16 encoding must begin with an XML encoding declaration, 
  132|       |     *    in which the first characters must be '<?xml', any conforming processor can detect, 
  133|       |     *    after two to four octets of input, which of the following cases apply. 
  134|       |     *
  135|       |     *    In reading this list, it may help to know that in UCS-4, '<' is "#x0000003C" and 
  136|       |     *    '?' is "#x0000003F", and the Byte Order Mark required of UTF-16 data streams is 
  137|       |     *    "#xFEFF". The notation ## is used to denote any byte value except that two consecutive 
  138|       |     *    ##s cannot be both 00.
  139|       |     *
  140|       |     *    With a Byte Order Mark:
  141|       |     *
  142|       |     *    00 00 FE FF           UCS-4,    big-endian machine    (1234 order) 
  143|       |     *    FF FE 00 00           UCS-4,    little-endian machine (4321 order) 
  144|       |     *    00 00 FF FE           UCS-4,    unusual octet order   (2143) 
  145|       |     *    FE FF 00 00           UCS-4,    unusual octet order   (3412) 
  146|       |     *    FE FF ## ##           UTF-16,   big-endian 
  147|       |     *    FF FE ## ##           UTF-16,   little-endian 
  148|       |     *    EF BB BF              UTF-8 
  149|       |     *
  150|       |     ***/
  151|       |
  152|       |    //
  153|       |    //  We have at least four bytes, so we can check all BOM
  154|       |    //  for UCS-4BE, UCS-4LE, UTF-16BE and UTF-16LE as well.
  155|       |    //
  156|      0|    if ((rawBuffer[0] == 0x00) && (rawBuffer[1] == 0x00) && (rawBuffer[2] == 0xFE) && (rawBuffer[3] == 0xFF))
  ------------------
  |  Branch (156:9): [True: 0, False: 0]
  |  Branch (156:35): [True: 0, False: 0]
  |  Branch (156:61): [True: 0, False: 0]
  |  Branch (156:87): [True: 0, False: 0]
  ------------------
  157|      0|        return UCS_4B;
  158|      0|    else if ((rawBuffer[0] == 0xFF) && (rawBuffer[1] == 0xFE) && (rawBuffer[2] == 0x00) && (rawBuffer[3] == 0x00))
  ------------------
  |  Branch (158:14): [True: 0, False: 0]
  |  Branch (158:40): [True: 0, False: 0]
  |  Branch (158:66): [True: 0, False: 0]
  |  Branch (158:92): [True: 0, False: 0]
  ------------------
  159|      0|        return UCS_4L;
  160|      0|    else if ((rawBuffer[0] == 0xFE) && (rawBuffer[1] == 0xFF))
  ------------------
  |  Branch (160:14): [True: 0, False: 0]
  |  Branch (160:40): [True: 0, False: 0]
  ------------------
  161|      0|        return UTF_16B;
  162|      0|    else if ((rawBuffer[0] == 0xFF) && (rawBuffer[1] == 0xFE))
  ------------------
  |  Branch (162:14): [True: 0, False: 0]
  |  Branch (162:40): [True: 0, False: 0]
  ------------------
  163|      0|        return UTF_16L;
  164|       |
  165|       |    //
  166|       |    //  We have at least 4 bytes. So lets check the 4 byte sequences that
  167|       |    //  indicate other UTF-16 and UCS encodings.
  168|       |    //
  169|      0|    if ((rawBuffer[0] == 0x00) || (rawBuffer[0] == 0x3C))
  ------------------
  |  Branch (169:9): [True: 0, False: 0]
  |  Branch (169:35): [True: 0, False: 0]
  ------------------
  170|      0|    {
  171|      0|        if (rawByteCount >= fgUCS4PreLen && !memcmp(rawBuffer, fgUCS4BPre, fgUCS4PreLen))
  ------------------
  |  Branch (171:13): [True: 0, False: 0]
  |  Branch (171:45): [True: 0, False: 0]
  ------------------
  172|      0|            return UCS_4B;
  173|      0|        else if (rawByteCount >= fgUCS4PreLen && !memcmp(rawBuffer, fgUCS4LPre, fgUCS4PreLen))
  ------------------
  |  Branch (173:18): [True: 0, False: 0]
  |  Branch (173:50): [True: 0, False: 0]
  ------------------
  174|      0|            return UCS_4L;
  175|      0|        else if (rawByteCount >= fgUTF16PreLen && !memcmp(rawBuffer, fgUTF16BPre, fgUTF16PreLen))
  ------------------
  |  Branch (175:18): [True: 0, False: 0]
  |  Branch (175:51): [True: 0, False: 0]
  ------------------
  176|      0|            return UTF_16B;
  177|      0|        else if (rawByteCount >= fgUTF16PreLen && !memcmp(rawBuffer, fgUTF16LPre, fgUTF16PreLen))
  ------------------
  |  Branch (177:18): [True: 0, False: 0]
  |  Branch (177:51): [True: 0, False: 0]
  ------------------
  178|      0|            return UTF_16L;
  179|      0|    }
  180|       |
  181|       |    //
  182|       |    //  See if we have enough bytes to possibly match the EBCDIC prefix.
  183|       |    //  If so, try it.
  184|       |    //
  185|      0|    if (rawByteCount > fgEBCDICPreLen)
  ------------------
  |  Branch (185:9): [True: 0, False: 0]
  ------------------
  186|      0|    {
  187|      0|        if (!memcmp(rawBuffer, fgEBCDICPre, fgEBCDICPreLen))
  ------------------
  |  Branch (187:13): [True: 0, False: 0]
  ------------------
  188|      0|            return EBCDIC;
  189|      0|    }
  190|       |
  191|       |    //
  192|       |    //  Does not seem to be anything we know, so go with UTF-8 to get at
  193|       |    //  least through the first line and see what it really is.
  194|       |    //
  195|      0|    return UTF_8;
  196|      0|}
_ZN11xercesc_3_213XMLRecognizer15encodingForNameEPKDs:
  201|  7.61k|{
  202|       |    //
  203|       |    //  Compare the passed string, assume input string is already uppercased,
  204|       |    //  to the variations that we recognize.
  205|       |    //
  206|       |    //  !!NOTE: Note that we don't handle EBCDIC here because we don't handle
  207|       |    //  that one ourselves. It is allowed to fall into 'other'.
  208|       |    //
  209|  7.61k|    if (encName == XMLUni::fgXMLChEncodingString ||
  ------------------
  |  Branch (209:9): [True: 0, False: 7.61k]
  ------------------
  210|  7.61k|        !XMLString::compareString(encName, XMLUni::fgXMLChEncodingString))
  ------------------
  |  Branch (210:9): [True: 0, False: 7.61k]
  ------------------
  211|      0|    {
  212|      0|        return XMLRecognizer::XERCES_XMLCH;
  213|      0|    }
  214|  7.61k|    else if (!XMLString::compareString(encName, XMLUni::fgUTF8EncodingString)
  ------------------
  |  Branch (214:14): [True: 82, False: 7.53k]
  ------------------
  215|  7.61k|         ||  !XMLString::compareString(encName, XMLUni::fgUTF8EncodingString2))
  ------------------
  |  Branch (215:14): [True: 1, False: 7.53k]
  ------------------
  216|     83|    {
  217|     83|        return XMLRecognizer::UTF_8;
  218|     83|    }
  219|  7.53k|    else if (!XMLString::compareString(encName, XMLUni::fgUSASCIIEncodingString)
  ------------------
  |  Branch (219:14): [True: 74, False: 7.46k]
  ------------------
  220|  7.53k|         ||  !XMLString::compareString(encName, XMLUni::fgUSASCIIEncodingString2)
  ------------------
  |  Branch (220:14): [True: 1, False: 7.46k]
  ------------------
  221|  7.53k|         ||  !XMLString::compareString(encName, XMLUni::fgUSASCIIEncodingString3)
  ------------------
  |  Branch (221:14): [True: 1, False: 7.46k]
  ------------------
  222|  7.53k|         ||  !XMLString::compareString(encName, XMLUni::fgUSASCIIEncodingString4))
  ------------------
  |  Branch (222:14): [True: 0, False: 7.46k]
  ------------------
  223|     76|    {
  224|     76|        return XMLRecognizer::US_ASCII;
  225|     76|    }
  226|  7.46k|    else if (!XMLString::compareString(encName, XMLUni::fgUTF16LEncodingString)
  ------------------
  |  Branch (226:14): [True: 0, False: 7.46k]
  ------------------
  227|  7.46k|         ||  !XMLString::compareString(encName, XMLUni::fgUTF16LEncodingString2))
  ------------------
  |  Branch (227:14): [True: 11, False: 7.44k]
  ------------------
  228|     11|    {
  229|     11|        return XMLRecognizer::UTF_16L;
  230|     11|    }
  231|  7.44k|    else if (!XMLString::compareString(encName, XMLUni::fgUTF16BEncodingString)
  ------------------
  |  Branch (231:14): [True: 0, False: 7.44k]
  ------------------
  232|  7.44k|         ||  !XMLString::compareString(encName, XMLUni::fgUTF16BEncodingString2))
  ------------------
  |  Branch (232:14): [True: 14, False: 7.43k]
  ------------------
  233|     14|    {
  234|     14|        return XMLRecognizer::UTF_16B;
  235|     14|    }
  236|  7.43k|    else if (!XMLString::compareString(encName, XMLUni::fgUTF16EncodingString))
  ------------------
  |  Branch (236:14): [True: 0, False: 7.43k]
  ------------------
  237|      0|    {
  238|      0|        return XMLPlatformUtils::fgXMLChBigEndian?XMLRecognizer::UTF_16B:XMLRecognizer::UTF_16L;
  ------------------
  |  Branch (238:16): [True: 0, False: 0]
  ------------------
  239|      0|    }
  240|  7.43k|    else if (!XMLString::compareString(encName, XMLUni::fgUCS4LEncodingString)
  ------------------
  |  Branch (240:14): [True: 0, False: 7.43k]
  ------------------
  241|  7.43k|         ||  !XMLString::compareString(encName, XMLUni::fgUCS4LEncodingString2))
  ------------------
  |  Branch (241:14): [True: 0, False: 7.43k]
  ------------------
  242|      0|    {
  243|      0|        return XMLRecognizer::UCS_4L;
  244|      0|    }
  245|  7.43k|    else if (!XMLString::compareString(encName, XMLUni::fgUCS4BEncodingString)
  ------------------
  |  Branch (245:14): [True: 0, False: 7.43k]
  ------------------
  246|  7.43k|         ||  !XMLString::compareString(encName, XMLUni::fgUCS4BEncodingString2))
  ------------------
  |  Branch (246:14): [True: 0, False: 7.43k]
  ------------------
  247|      0|    {
  248|      0|        return XMLRecognizer::UCS_4B;
  249|      0|    }
  250|  7.43k|    else if (!XMLString::compareString(encName, XMLUni::fgUCS4EncodingString))
  ------------------
  |  Branch (250:14): [True: 0, False: 7.43k]
  ------------------
  251|      0|    {
  252|      0|        return XMLPlatformUtils::fgXMLChBigEndian?XMLRecognizer::UCS_4B:XMLRecognizer::UCS_4L;
  ------------------
  |  Branch (252:16): [True: 0, False: 0]
  ------------------
  253|      0|    }
  254|       |
  255|       |    // Return 'other' since we don't recognizer it
  256|  7.43k|    return XMLRecognizer::OtherEncoding;
  257|  7.61k|}
_ZN11xercesc_3_213XMLRecognizer15nameForEncodingENS0_9EncodingsEPNS_13MemoryManagerE:
  263|  25.4k|{
  264|  25.4k|    if (theEncoding >= Encodings_Count)
  ------------------
  |  Branch (264:9): [True: 0, False: 25.4k]
  ------------------
  265|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::XMLRec_UnknownEncoding, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  266|       |
  267|  25.4k|    return gEncodingNameMap[theEncoding];
  268|  25.4k|}

_ZN11xercesc_3_210XMLRefInfoD2Ev:
  142|  5.31k|{
  143|  5.31k|    fMemoryManager->deallocate(fRefName);
  144|  5.31k|}
_ZNK11xercesc_3_210XMLRefInfo11getDeclaredEv:
  151|  13.0k|{
  152|  13.0k|    return fDeclared;
  153|  13.0k|}
_ZNK11xercesc_3_210XMLRefInfo10getRefNameEv:
  156|  5.93k|{
  157|  5.93k|    return fRefName;
  158|  5.93k|}
_ZNK11xercesc_3_210XMLRefInfo7getUsedEv:
  161|  1.06k|{
  162|  1.06k|    return fUsed;
  163|  1.06k|}
_ZN11xercesc_3_210XMLRefInfo11setDeclaredEb:
  170|  1.21k|{
  171|  1.21k|    fDeclared = newValue;
  172|  1.21k|}
_ZN11xercesc_3_210XMLRefInfo7setUsedEb:
  175|  13.6k|{
  176|  13.6k|    fUsed = newValue;
  177|  13.6k|}
_ZN11xercesc_3_210XMLRefInfoC2EPKDsbbPNS_13MemoryManagerE:
  137|  5.31k|{
  138|  5.31k|    fRefName = XMLString::replicate(refName, fMemoryManager);
  139|  5.31k|}

_ZN11xercesc_3_214XMLInitializer22initializeXMLValidatorEv:
   36|      1|{
   37|      1|    sMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgValidityDomain);
   38|       |
   39|      1|    if (!sMsgLoader)
  ------------------
  |  Branch (39:9): [True: 0, False: 1]
  ------------------
   40|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   41|      1|}
_ZN11xercesc_3_212XMLValidator9emitErrorENS_8XMLValid5CodesE:
   59|  33.6k|{
   60|       |    // Bump the error count if it is not a warning
   61|  33.6k|    if (XMLValid::errorType(toEmit) != XMLErrorReporter::ErrType_Warning)
  ------------------
  |  Branch (61:9): [True: 33.6k, False: 0]
  ------------------
   62|  33.6k|        fScanner->incrementErrorCount();
   63|       |
   64|       |    //	Call error reporter if we have one
   65|  33.6k|    if (fErrorReporter)
  ------------------
  |  Branch (65:9): [True: 0, False: 33.6k]
  ------------------
   66|      0|    {
   67|       |        // Load the message into a local for display
   68|      0|        const XMLSize_t msgSize = 1023;
   69|      0|        XMLCh errText[msgSize + 1];
   70|       |
   71|       |        // load the text
   72|      0|        if (!sMsgLoader->loadMsg(toEmit, errText, msgSize))
  ------------------
  |  Branch (72:13): [True: 0, False: 0]
  ------------------
   73|      0|        {
   74|       |          // <TBD> Probably should load a default msg here
   75|      0|        }
   76|       |
   77|       |        //
   78|       |        //  Create a LastExtEntityInfo structure and get the reader manager
   79|       |        //  to fill it in for us. This will give us the information about
   80|       |        //  the last reader on the stack that was an external entity of some
   81|       |        //  sort (i.e. it will ignore internal entities.
   82|       |        //
   83|      0|        ReaderMgr::LastExtEntityInfo lastInfo;
   84|      0|        fReaderMgr->getLastExtEntityInfo(lastInfo);
   85|       |
   86|      0|        fErrorReporter->error
   87|      0|        (
   88|      0|            toEmit
   89|      0|            , XMLUni::fgValidityDomain
   90|      0|            , XMLValid::errorType(toEmit)
   91|      0|            , errText
   92|      0|            , lastInfo.systemId
   93|      0|            , lastInfo.publicId
   94|      0|            , lastInfo.lineNumber
   95|      0|            , lastInfo.colNumber
   96|      0|        );
   97|      0|    }
   98|       |
   99|       |    // Bail out if its fatal an we are to give up on the first fatal error
  100|  33.6k|    if (((XMLValid::isError(toEmit) && fScanner->getValidationConstraintFatal())
  ------------------
  |  Branch (100:11): [True: 33.6k, False: 0]
  |  Branch (100:40): [True: 0, False: 33.6k]
  ------------------
  101|  33.6k|         || XMLValid::isFatal(toEmit))
  ------------------
  |  Branch (101:13): [True: 0, False: 33.6k]
  ------------------
  102|  33.6k|    &&  fScanner->getExitOnFirstFatal()
  ------------------
  |  Branch (102:9): [True: 0, False: 0]
  ------------------
  103|  33.6k|    &&  !fScanner->getInException())
  ------------------
  |  Branch (103:9): [True: 0, False: 0]
  ------------------
  104|      0|    {
  105|      0|        throw toEmit;
  106|      0|    }
  107|  33.6k|}
_ZN11xercesc_3_212XMLValidator9emitErrorENS_8XMLValid5CodesEPKDsS4_S4_S4_:
  114|  1.24M|{
  115|       |    // Bump the error count if it is not a warning
  116|  1.24M|    if (XMLValid::errorType(toEmit) != XMLErrorReporter::ErrType_Warning)
  ------------------
  |  Branch (116:9): [True: 1.24M, False: 0]
  ------------------
  117|  1.24M|        fScanner->incrementErrorCount();
  118|       |
  119|       |    //	Call error reporter if we have one
  120|  1.24M|    if (fErrorReporter)
  ------------------
  |  Branch (120:9): [True: 0, False: 1.24M]
  ------------------
  121|      0|    {
  122|       |        //
  123|       |        //  Load the message into alocal and replace any tokens found in
  124|       |        //  the text.
  125|       |        //
  126|      0|        const XMLSize_t maxChars = 2047;
  127|      0|        XMLCh errText[maxChars + 1];
  128|       |
  129|       |        // load the text
  130|      0|        if (!sMsgLoader->loadMsg(toEmit, errText, maxChars, text1, text2, text3, text4, fScanner->getMemoryManager()))
  ------------------
  |  Branch (130:13): [True: 0, False: 0]
  ------------------
  131|      0|        {
  132|       |          // <TBD> Should probably load a default message here
  133|      0|        }
  134|       |
  135|       |        //
  136|       |        //  Create a LastExtEntityInfo structure and get the reader manager
  137|       |        //  to fill it in for us. This will give us the information about
  138|       |        //  the last reader on the stack that was an external entity of some
  139|       |        //  sort (i.e. it will ignore internal entities.
  140|       |        //
  141|      0|        ReaderMgr::LastExtEntityInfo lastInfo;
  142|      0|        fReaderMgr->getLastExtEntityInfo(lastInfo);
  143|       |
  144|      0|        fErrorReporter->error
  145|      0|        (
  146|      0|            toEmit
  147|      0|            , XMLUni::fgValidityDomain
  148|      0|            , XMLValid::errorType(toEmit)
  149|      0|            , errText
  150|      0|            , lastInfo.systemId
  151|      0|            , lastInfo.publicId
  152|      0|            , lastInfo.lineNumber
  153|      0|            , lastInfo.colNumber
  154|      0|        );
  155|      0|    }
  156|       |
  157|       |    // Bail out if its fatal an we are to give up on the first fatal error
  158|  1.24M|    if (((XMLValid::isError(toEmit) && fScanner->getValidationConstraintFatal())
  ------------------
  |  Branch (158:11): [True: 1.24M, False: 0]
  |  Branch (158:40): [True: 0, False: 1.24M]
  ------------------
  159|  1.24M|         || XMLValid::isFatal(toEmit))
  ------------------
  |  Branch (159:13): [True: 0, False: 1.24M]
  ------------------
  160|  1.24M|    &&  fScanner->getExitOnFirstFatal()
  ------------------
  |  Branch (160:9): [True: 0, False: 0]
  ------------------
  161|  1.24M|    &&  !fScanner->getInException())
  ------------------
  |  Branch (161:9): [True: 0, False: 0]
  ------------------
  162|      0|    {
  163|      0|        throw toEmit;
  164|      0|    }
  165|  1.24M|}
_ZN11xercesc_3_212XMLValidatorC2EPNS_16XMLErrorReporterE:
  293|  17.0k|{
  294|  17.0k|}

_ZN11xercesc_3_212XMLValidatorD2Ev:
   67|  17.0k|    {
   68|  17.0k|    }
_ZN11xercesc_3_212XMLValidator14setScannerInfoEPNS_10XMLScannerEPNS_9ReaderMgrEPNS_12XMLBufferMgrE:
  377|  17.0k|{
  378|       |    // We don't own any of these, we just reference them
  379|  17.0k|    fScanner = owningScanner;
  380|  17.0k|    fReaderMgr = readerMgr;
  381|  17.0k|    fBufMgr = bufMgr;
  382|  17.0k|}
_ZN11xercesc_3_212XMLValidator16setErrorReporterEPNS_16XMLErrorReporterE:
  386|  34.0k|{
  387|  34.0k|    fErrorReporter = errorReporter;
  388|  34.0k|}
_ZN11xercesc_3_212XMLValidator12getReaderMgrEv:
  410|   122k|{
  411|   122k|    return fReaderMgr;
  412|   122k|}
_ZN11xercesc_3_212XMLValidator10getScannerEv:
  420|   126k|{
  421|   126k|    return fScanner;
  422|   126k|}

_ZN11xercesc_3_28XMLValid9errorTypeENS0_5CodesE:
  119|  1.27M|    {
  120|  1.27M|       if ((toCheck >= W_LowBounds) && (toCheck <= W_HighBounds))
  ------------------
  |  Branch (120:12): [True: 0, False: 1.27M]
  |  Branch (120:40): [True: 0, False: 0]
  ------------------
  121|      0|           return XMLErrorReporter::ErrType_Warning;
  122|  1.27M|       else if ((toCheck >= F_LowBounds) && (toCheck <= F_HighBounds))
  ------------------
  |  Branch (122:17): [True: 0, False: 1.27M]
  |  Branch (122:45): [True: 0, False: 0]
  ------------------
  123|      0|            return XMLErrorReporter::ErrType_Fatal;
  124|  1.27M|       else if ((toCheck >= E_LowBounds) && (toCheck <= E_HighBounds))
  ------------------
  |  Branch (124:17): [True: 1.27M, False: 0]
  |  Branch (124:45): [True: 1.27M, False: 0]
  ------------------
  125|  1.27M|            return XMLErrorReporter::ErrType_Error;
  126|      0|       return XMLErrorReporter::ErrTypes_Unknown;
  127|  1.27M|    }
_ZN11xercesc_3_28XMLValid7isErrorENS0_5CodesE:
  114|  1.27M|    {
  115|  1.27M|        return ((toCheck >= E_LowBounds) && (toCheck <= E_HighBounds));
  ------------------
  |  Branch (115:17): [True: 1.27M, False: 0]
  |  Branch (115:45): [True: 1.27M, False: 0]
  ------------------
  116|  1.27M|    }
_ZN11xercesc_3_28XMLValid7isFatalENS0_5CodesE:
  104|  1.27M|    {
  105|  1.27M|        return ((toCheck >= F_LowBounds) && (toCheck <= F_HighBounds));
  ------------------
  |  Branch (105:17): [True: 0, False: 1.27M]
  |  Branch (105:45): [True: 0, False: 0]
  ------------------
  106|  1.27M|    }

_ZN11xercesc_3_217PSVIAttributeListC2EPNS_13MemoryManagerE:
   32|  8.51k|{
   33|  8.51k|    fAttrList= new (fMemoryManager) RefVectorOf<PSVIAttributeStorage> (10, true, fMemoryManager);
   34|  8.51k|}

_ZN11xercesc_3_217PSVIAttributeListD2Ev:
  183|  8.51k|{
  184|  8.51k|    delete fAttrList;
  185|  8.51k|}

_ZN11xercesc_3_211PSVIElementC2EPNS_13MemoryManagerE:
   34|  8.51k|{
   35|  8.51k|}
_ZN11xercesc_3_211PSVIElementD2Ev:
   38|  8.51k|{
   39|  8.51k|    fMemoryManager->deallocate(fCanonicalValue);
   40|  8.51k|}

_ZN11xercesc_3_28PSVIItemC2EPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}

_ZN11xercesc_3_28PSVIItemD2Ev:
  270|  8.51k|inline PSVIItem::~PSVIItem() {}

_ZN11xercesc_3_214XMLInitializer17initializeXSValueEv:
  149|      1|{
  150|      1|    sXSValueRegEx = new RegularExpression(
  151|      1|      XMLUni::fgLangPattern, SchemaSymbols::fgRegEx_XOption);
  152|       |
  153|      1|    XSValue::initializeRegistry();
  154|      1|}
_ZN11xercesc_3_27XSValue18initializeRegistryEv:
  175|      1|{
  176|       |    //using the XMLPlatformUtils::fgMemoryManager
  177|      1|    fDataTypeRegistry  = new ValueHashTableOf<XSValue::DataType>(43);
  178|       |
  179|      1|    if (fDataTypeRegistry) {
  ------------------
  |  Branch (179:9): [True: 1, False: 0]
  ------------------
  180|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_STRING,             XSValue::dt_string);
  181|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN,            XSValue::dt_boolean);
  182|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL,            XSValue::dt_decimal);
  183|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_FLOAT,              XSValue::dt_float);
  184|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE,             XSValue::dt_double);
  185|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DURATION,           XSValue::dt_duration);
  186|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DATETIME,           XSValue::dt_dateTime);
  187|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_TIME,               XSValue::dt_time);
  188|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DATE,               XSValue::dt_date);
  189|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH,          XSValue::dt_gYearMonth);
  190|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_YEAR,               XSValue::dt_gYear);
  191|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY,           XSValue::dt_gMonthDay);
  192|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_DAY,                XSValue::dt_gDay);
  193|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_MONTH,              XSValue::dt_gMonth);
  194|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY,          XSValue::dt_hexBinary);
  195|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY,       XSValue::dt_base64Binary);
  196|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_ANYURI,             XSValue::dt_anyURI);
  197|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_QNAME,              XSValue::dt_QName);
  198|      1|        fDataTypeRegistry->put((void*) XMLUni::fgNotationString,               XSValue::dt_NOTATION);
  199|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NORMALIZEDSTRING,   XSValue::dt_normalizedString);
  200|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_TOKEN,              XSValue::dt_token);
  201|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_LANGUAGE,           XSValue::dt_language);
  202|      1|        fDataTypeRegistry->put((void*) XMLUni::fgNmTokenString,                XSValue::dt_NMTOKEN);
  203|      1|        fDataTypeRegistry->put((void*) XMLUni::fgNmTokensString,               XSValue::dt_NMTOKENS);
  204|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NAME,               XSValue::dt_Name);
  205|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NCNAME,             XSValue::dt_NCName);
  206|      1|        fDataTypeRegistry->put((void*) XMLUni::fgIDString,                     XSValue::dt_ID);
  207|      1|        fDataTypeRegistry->put((void*) XMLUni::fgIDRefString,                  XSValue::dt_IDREF);
  208|      1|        fDataTypeRegistry->put((void*) XMLUni::fgIDRefsString,                 XSValue::dt_IDREFS);
  209|      1|        fDataTypeRegistry->put((void*) XMLUni::fgEntityString,                 XSValue::dt_ENTITY);
  210|      1|        fDataTypeRegistry->put((void*) XMLUni::fgEntitiesString,               XSValue::dt_ENTITIES);
  211|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_INTEGER,            XSValue::dt_integer);
  212|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NONPOSITIVEINTEGER, XSValue::dt_nonPositiveInteger);
  213|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NEGATIVEINTEGER,    XSValue::dt_negativeInteger);
  214|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_LONG,               XSValue::dt_long);
  215|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_INT,                XSValue::dt_int);
  216|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_SHORT,              XSValue::dt_short);
  217|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_BYTE,               XSValue::dt_byte);
  218|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_NONNEGATIVEINTEGER, XSValue::dt_nonNegativeInteger);
  219|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_ULONG,              XSValue::dt_unsignedLong);
  220|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_UINT,               XSValue::dt_unsignedInt);
  221|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_USHORT,             XSValue::dt_unsignedShort);
  222|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_UBYTE,              XSValue::dt_unsignedByte);
  223|      1|        fDataTypeRegistry->put((void*) SchemaSymbols::fgDT_POSITIVEINTEGER,    XSValue::dt_positiveInteger);
  224|      1|    }
  225|      1|}

_ZN11xercesc_3_29ElemStackC2EPNS_13MemoryManagerE:
   53|  8.51k|{
   54|       |    // Do an initial allocation of the stack and zero it out
   55|  8.51k|    fStack = (StackElem**) fMemoryManager->allocate
   56|  8.51k|    (
   57|  8.51k|        fStackCapacity * sizeof(StackElem*)
   58|  8.51k|    );//new StackElem*[fStackCapacity];
   59|  8.51k|    memset(fStack, 0, fStackCapacity * sizeof(StackElem*));
   60|       |
   61|  8.51k|    fNamespaceMap = new (fMemoryManager) ValueVectorOf<PrefMapElem*>(16, fMemoryManager);
   62|  8.51k|}
_ZN11xercesc_3_29ElemStackD2Ev:
   65|  8.51k|{
   66|  8.51k|    if(fGlobalNamespaces)
  ------------------
  |  Branch (66:8): [True: 0, False: 8.51k]
  ------------------
   67|      0|    {
   68|      0|        fMemoryManager->deallocate(fGlobalNamespaces->fMap);
   69|      0|        delete fGlobalNamespaces;
   70|      0|    }
   71|       |
   72|       |    //
   73|       |    //  Start working from the bottom of the stack and clear it out as we
   74|       |    //  go up. Once we hit an uninitialized one, we can break out.
   75|       |    //
   76|   301k|    for (XMLSize_t stackInd = 0; stackInd < fStackCapacity; stackInd++)
  ------------------
  |  Branch (76:34): [True: 301k, False: 5]
  ------------------
   77|   301k|    {
   78|       |        // If this entry has been set, then lets clean it up
   79|   301k|        if (!fStack[stackInd])
  ------------------
  |  Branch (79:13): [True: 8.51k, False: 293k]
  ------------------
   80|  8.51k|            break;
   81|       |
   82|   293k|        fMemoryManager->deallocate(fStack[stackInd]->fChildren);//delete [] fStack[stackInd]->fChildren;
   83|   293k|        fMemoryManager->deallocate(fStack[stackInd]->fMap);//delete [] fStack[stackInd]->fMap;
   84|   293k|        fMemoryManager->deallocate(fStack[stackInd]->fSchemaElemName);
   85|   293k|        delete fStack[stackInd];
   86|   293k|    }
   87|       |
   88|       |    // Delete the stack array itself now
   89|  8.51k|    fMemoryManager->deallocate(fStack);//delete [] fStack;
   90|  8.51k|    delete fNamespaceMap;
   91|  8.51k|}
_ZN11xercesc_3_29ElemStack8addLevelEPNS_14XMLElementDeclEm:
  135|   558k|{
  136|       |    // See if we need to expand the stack
  137|   558k|    if (fStackTop == fStackCapacity)
  ------------------
  |  Branch (137:9): [True: 641, False: 557k]
  ------------------
  138|    641|        expandStack();
  139|       |
  140|       |    // If this element has not been initialized yet, then initialize it
  141|   558k|    if (!fStack[fStackTop])
  ------------------
  |  Branch (141:9): [True: 293k, False: 265k]
  ------------------
  142|   293k|    {
  143|   293k|        fStack[fStackTop] = new (fMemoryManager) StackElem;
  144|   293k|        fStack[fStackTop]->fChildCapacity = 0;
  145|   293k|        fStack[fStackTop]->fChildren = 0;
  146|   293k|        fStack[fStackTop]->fMapCapacity = 0;
  147|   293k|        fStack[fStackTop]->fMap = 0;
  148|   293k|        fStack[fStackTop]->fSchemaElemName = 0;
  149|   293k|        fStack[fStackTop]->fSchemaElemNameMaxLen = 0;
  150|   293k|    }
  151|       |
  152|       |    // Set up the new top row
  153|   558k|    fStack[fStackTop]->fThisElement = toSet;
  154|   558k|    fStack[fStackTop]->fReaderNum = readerNum;
  155|   558k|    fStack[fStackTop]->fChildCount = 0;
  156|   558k|    fStack[fStackTop]->fMapCount = 0;
  157|   558k|    fStack[fStackTop]->fValidationFlag = false;
  158|   558k|    fStack[fStackTop]->fCommentOrPISeen = false;
  159|   558k|    fStack[fStackTop]->fReferenceEscaped = false;
  160|   558k|    fStack[fStackTop]->fCurrentURI = fUnknownNamespaceId;
  161|   558k|    fStack[fStackTop]->fCurrentScope = Grammar::TOP_LEVEL_SCOPE;
  162|   558k|    fStack[fStackTop]->fCurrentGrammar = 0;
  163|       |
  164|       |    // Bump the top of stack
  165|   558k|    fStackTop++;
  166|       |
  167|   558k|    return fStackTop-1;
  168|   558k|}
_ZN11xercesc_3_29ElemStack6popTopEv:
  173|   271k|{
  174|       |    // Watch for an underflow error
  175|   271k|    if (!fStackTop)
  ------------------
  |  Branch (175:9): [True: 0, False: 271k]
  ------------------
  176|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_StackUnderflow, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  177|       |
  178|   271k|    fStackTop--;
  179|   271k|    return fStack[fStackTop];
  180|   271k|}
_ZN11xercesc_3_29ElemStack8addChildEPNS_5QNameEb:
  198|   554k|{
  199|   554k|    if (!fStackTop)
  ------------------
  |  Branch (199:9): [True: 0, False: 554k]
  ------------------
  200|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  201|       |
  202|       |    //
  203|       |    //  If they want to add to the parent, then we have to have at least two
  204|       |    //  elements on the stack.
  205|       |    //
  206|   554k|    if (toParent && (fStackTop < 2))
  ------------------
  |  Branch (206:9): [True: 554k, False: 0]
  |  Branch (206:21): [True: 0, False: 554k]
  ------------------
  207|      0|        ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::ElemStack_NoParentPushed, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  208|       |
  209|       |    // Get a convenience pointer to the stack top row
  210|   554k|    StackElem* curRow = toParent
  ------------------
  |  Branch (210:25): [True: 554k, False: 0]
  ------------------
  211|   554k|                        ? fStack[fStackTop - 2] : fStack[fStackTop - 1];
  212|       |
  213|       |    // See if we need to expand this row's child array
  214|   554k|    if (curRow->fChildCount == curRow->fChildCapacity)
  ------------------
  |  Branch (214:9): [True: 291k, False: 263k]
  ------------------
  215|   291k|    {
  216|       |        // Increase the capacity by a quarter and allocate a new row
  217|   291k|        const XMLSize_t newCapacity = curRow->fChildCapacity ?
  ------------------
  |  Branch (217:39): [True: 1.88k, False: 289k]
  ------------------
  218|  1.88k|                                      (XMLSize_t)(curRow->fChildCapacity * 1.25) :
  219|   291k|                                      32;
  220|   291k|        QName** newRow = (QName**) fMemoryManager->allocate
  221|   291k|        (
  222|   291k|            newCapacity * sizeof(QName*)
  223|   291k|        );//new QName*[newCapacity];
  224|       |
  225|       |        //
  226|       |        //  Copy over the old contents. We don't have to initialize the new
  227|       |        //  part because The current child count is used to know how much of
  228|       |        //  it is valid.
  229|       |        //
  230|       |        //  Only both doing this if there is any current content, since
  231|       |        //  this code also does the initial faulting in of the array when
  232|       |        //  both the current capacity and child count are zero.
  233|       |        //
  234|   794k|        for (XMLSize_t index = 0; index < curRow->fChildCount; index++)
  ------------------
  |  Branch (234:35): [True: 503k, False: 291k]
  ------------------
  235|   503k|            newRow[index] = curRow->fChildren[index];
  236|       |
  237|       |        // Clean up the old children and store the new info
  238|   291k|        fMemoryManager->deallocate(curRow->fChildren);//delete [] curRow->fChildren;
  239|   291k|        curRow->fChildren = newRow;
  240|   291k|        curRow->fChildCapacity = newCapacity;
  241|   291k|    }
  242|       |
  243|       |    // Add this id to the end of the row's child id array and bump the count
  244|   554k|    curRow->fChildren[curRow->fChildCount++] = child;
  245|       |
  246|       |    // Return the level of the index we just filled (before the bump)
  247|   554k|    return curRow->fChildCount - 1;
  248|   554k|}
_ZNK11xercesc_3_29ElemStack10topElementEv:
  251|  1.13M|{
  252|  1.13M|    if (!fStackTop)
  ------------------
  |  Branch (252:9): [True: 0, False: 1.13M]
  ------------------
  253|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::ElemStack_EmptyStack, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  254|       |
  255|  1.13M|    return fStack[fStackTop - 1];
  256|  1.13M|}
_ZN11xercesc_3_29ElemStack5resetEjjjj:
  445|  8.51k|{
  446|  8.51k|    if(fGlobalNamespaces)
  ------------------
  |  Branch (446:8): [True: 0, False: 8.51k]
  ------------------
  447|      0|    {
  448|      0|        fMemoryManager->deallocate(fGlobalNamespaces->fMap);
  449|      0|        delete fGlobalNamespaces;
  450|      0|        fGlobalNamespaces = 0;
  451|      0|    }
  452|       |
  453|       |    // Reset the stack top to clear the stack
  454|  8.51k|    fStackTop = 0;
  455|       |
  456|       |    // if first time, put in the standard prefixes
  457|  8.51k|    if (fXMLPoolId == 0) {
  ------------------
  |  Branch (457:9): [True: 8.51k, False: 0]
  ------------------
  458|       |
  459|  8.51k|        fGlobalPoolId = fPrefixPool.addOrFind(XMLUni::fgZeroLenString);
  460|  8.51k|        fXMLPoolId = fPrefixPool.addOrFind(XMLUni::fgXMLString);
  461|  8.51k|        fXMLNSPoolId = fPrefixPool.addOrFind(XMLUni::fgXMLNSString);
  462|  8.51k|    }
  463|       |
  464|       |    // And store the new special URI ids
  465|  8.51k|    fEmptyNamespaceId = emptyId;
  466|  8.51k|    fUnknownNamespaceId = unknownId;
  467|  8.51k|    fXMLNamespaceId = xmlId;
  468|  8.51k|    fXMLNSNamespaceId = xmlNSId;
  469|  8.51k|}
_ZN11xercesc_3_29ElemStack11expandStackEv:
  505|    641|{
  506|       |    // Expand the capacity by 25% and allocate a new buffer
  507|    641|    const XMLSize_t newCapacity = (XMLSize_t)(fStackCapacity * 1.25);
  508|    641|    StackElem** newStack = (StackElem**) fMemoryManager->allocate
  509|    641|    (
  510|    641|        newCapacity * sizeof(StackElem*)
  511|    641|    );//new StackElem*[newCapacity];
  512|       |
  513|       |    // Copy over the old stuff
  514|    641|    memcpy(newStack, fStack, fStackCapacity * sizeof(StackElem*));
  515|       |
  516|       |    //
  517|       |    //  And zero out the new stuff. Though we use a stack top, we reuse old
  518|       |    //  stack contents so we need to know if elements have been initially
  519|       |    //  allocated or not as we push new stuff onto the stack.
  520|       |    //
  521|    641|    memset
  522|    641|    (
  523|    641|        &newStack[fStackCapacity]
  524|    641|        , 0
  525|    641|        , (newCapacity - fStackCapacity) * sizeof(StackElem*)
  526|    641|    );
  527|       |
  528|       |    // Delete the old array and update our members
  529|    641|    fMemoryManager->deallocate(fStack);//delete [] fStack;
  530|    641|    fStack = newStack;
  531|    641|    fStackCapacity = newCapacity;
  532|    641|}

_ZNK11xercesc_3_29ElemStack7isEmptyEv:
  464|   845k|{
  465|   845k|    return (fStackTop == 0);
  466|   845k|}
_ZN11xercesc_3_29ElemStack17getValidationFlagEv:
  469|   268k|{
  470|   268k|    return fStack[fStackTop-1]->fValidationFlag;
  471|   268k|}
_ZN11xercesc_3_29ElemStack17setValidationFlagEb:
  474|   558k|{
  475|   558k|    fStack[fStackTop-1]->fValidationFlag = validationFlag;
  476|   558k|}
_ZN11xercesc_3_29ElemStack18setCommentOrPISeenEv:
  484|  6.58k|{
  485|  6.58k|    fStack[fStackTop-1]->fCommentOrPISeen = true;
  486|  6.58k|}
_ZN11xercesc_3_29ElemStack19setReferenceEscapedEv:
  494|  1.69k|{
  495|  1.69k|    fStack[fStackTop-1]->fReferenceEscaped = true;
  496|  1.69k|}

_ZN11xercesc_3_220EndOfEntityExceptionC2EPNS_13XMLEntityDeclEm:
   50|  5.45k|    {
   51|  5.45k|    }
_ZN11xercesc_3_220EndOfEntityExceptionD2Ev:
   61|  5.45k|    {
   62|  5.45k|    }

_ZN11xercesc_3_212IGXMLScannerC2EPNS_12XMLValidatorEPNS_15GrammarResolverEPNS_13MemoryManagerE:
   88|  8.51k|{
   89|  8.51k|    CleanupType cleanup(this, &IGXMLScanner::cleanUp);
   90|       |
   91|  8.51k|    try
   92|  8.51k|    {
   93|  8.51k|        commonInit();
   94|  8.51k|    }
   95|  8.51k|    catch(const OutOfMemoryException&)
   96|  8.51k|    {
   97|       |        // Don't cleanup when out of memory, since executing the
   98|       |        // code can cause problems.
   99|      0|        cleanup.release();
  100|       |
  101|      0|        throw;
  102|      0|    }
  103|       |
  104|  8.51k|    cleanup.release();
  105|  8.51k|}
_ZN11xercesc_3_212IGXMLScannerD2Ev:
  161|  8.51k|{
  162|  8.51k|    cleanUp();
  163|  8.51k|}
_ZN11xercesc_3_212IGXMLScanner12scanDocumentERKNS_11InputSourceE:
  186|  8.51k|{
  187|       |    //  Bump up the sequence id for this parser instance. This will invalidate
  188|       |    //  any previous progressive scan tokens.
  189|  8.51k|    fSequenceId++;
  190|       |
  191|  8.51k|    ReaderMgrResetType  resetReaderMgr(&fReaderMgr, &ReaderMgr::reset);
  192|       |
  193|  8.51k|    try
  194|  8.51k|    {
  195|       |        //  Reset the scanner and its plugged in stuff for a new run. This
  196|       |        //  resets all the data structures, creates the initial reader and
  197|       |        //  pushes it on the stack, and sets up the base document path.
  198|  8.51k|        scanReset(src);
  199|       |
  200|       |        // If we have a document handler, then call the start document
  201|  8.51k|        if (fDocHandler)
  ------------------
  |  Branch (201:13): [True: 0, False: 8.51k]
  ------------------
  202|      0|            fDocHandler->startDocument();
  203|       |
  204|       |        //  Scan the prolog part, which is everything before the root element
  205|       |        //  including the DTD subsets.
  206|  8.51k|        scanProlog();
  207|       |
  208|       |        //  If we got to the end of input, then its not a valid XML file.
  209|       |        //  Else, go on to scan the content.
  210|  8.51k|        if (fReaderMgr.atEOF())
  ------------------
  |  Branch (210:13): [True: 0, False: 8.51k]
  ------------------
  211|      0|        {
  212|      0|            emitError(XMLErrs::EmptyMainEntity);
  213|      0|        }
  214|  8.51k|        else
  215|  8.51k|        {
  216|       |            // Scan content, and tell it its not an external entity
  217|  8.51k|            if (scanContent())
  ------------------
  |  Branch (217:17): [True: 1.42k, False: 7.08k]
  ------------------
  218|  1.42k|            {
  219|       |                // Do post-parse validation if required
  220|  1.42k|                if (fValidate)
  ------------------
  |  Branch (220:21): [True: 1.42k, False: 0]
  ------------------
  221|  1.42k|                {
  222|       |                    //  We handle ID reference semantics at this level since
  223|       |                    //  its required by XML 1.0.
  224|  1.42k|                    checkIDRefs();
  225|       |
  226|       |                    // Then allow the validator to do any extra stuff it wants
  227|       |//                    fValidator->postParseValidation();
  228|  1.42k|                }
  229|       |
  230|       |                // That went ok, so scan for any miscellaneous stuff
  231|  1.42k|                if (!fReaderMgr.atEOF())
  ------------------
  |  Branch (231:21): [True: 1.42k, False: 0]
  ------------------
  232|  1.42k|                    scanMiscellaneous();
  233|  1.42k|            }
  234|  8.51k|        }
  235|       |
  236|       |        // If we have a document handler, then call the end document
  237|  8.51k|        if (fDocHandler)
  ------------------
  |  Branch (237:13): [True: 0, False: 8.51k]
  ------------------
  238|      0|            fDocHandler->endDocument();
  239|       |
  240|       |        //cargill debug:
  241|       |        //fGrammarResolver->getXSModel();
  242|  8.51k|    }
  243|       |    //  NOTE:
  244|       |    //
  245|       |    //  In all of the error processing below, the emitError() call MUST come
  246|       |    //  before the flush of the reader mgr, or it will fail because it tries
  247|       |    //  to find out the position in the XML source of the error.
  248|  8.51k|    catch(const XMLErrs::Codes)
  249|  8.51k|    {
  250|       |        // This is a 'first failure' exception, so fall through
  251|  5.29k|    }
  252|  8.51k|    catch(const XMLValid::Codes)
  253|  8.51k|    {
  254|       |        // This is a 'first fatal error' type exit, so fall through
  255|      0|    }
  256|  8.51k|    catch(const XMLException& excToCatch)
  257|  8.51k|    {
  258|       |        //  Emit the error and catch any user exception thrown from here. Make
  259|       |        //  sure in all cases we flush the reader manager.
  260|  2.95k|        fInException = true;
  261|  2.95k|        try
  262|  2.95k|        {
  263|  2.95k|            if (excToCatch.getErrorType() == XMLErrorReporter::ErrType_Warning)
  ------------------
  |  Branch (263:17): [True: 0, False: 2.95k]
  ------------------
  264|      0|                emitError
  265|      0|                (
  266|      0|                    XMLErrs::XMLException_Warning
  267|      0|                    , excToCatch.getCode()
  268|      0|                    , excToCatch.getMessage()
  269|      0|                );
  270|  2.95k|            else if (excToCatch.getErrorType() >= XMLErrorReporter::ErrType_Fatal)
  ------------------
  |  Branch (270:22): [True: 2.95k, False: 0]
  ------------------
  271|  2.95k|                emitError
  272|  2.95k|                (
  273|  2.95k|                    XMLErrs::XMLException_Fatal
  274|  2.95k|                    , excToCatch.getCode()
  275|  2.95k|                    , excToCatch.getMessage()
  276|  2.95k|                );
  277|      0|            else
  278|      0|                emitError
  279|      0|                (
  280|      0|                    XMLErrs::XMLException_Error
  281|      0|                    , excToCatch.getCode()
  282|      0|                    , excToCatch.getMessage()
  283|      0|                );
  284|  2.95k|        }
  285|  2.95k|        catch(const OutOfMemoryException&)
  286|  2.95k|        {
  287|       |            // This is a special case for out-of-memory
  288|       |            // conditions, because resetting the ReaderMgr
  289|       |            // can be problematic.
  290|      0|            resetReaderMgr.release();
  291|       |
  292|      0|            throw;
  293|      0|        }
  294|  2.95k|    }
  295|  8.51k|    catch(const OutOfMemoryException&)
  296|  8.51k|    {
  297|       |        // This is a special case for out-of-memory
  298|       |        // conditions, because resetting the ReaderMgr
  299|       |        // can be problematic.
  300|      0|        resetReaderMgr.release();
  301|       |
  302|      0|        throw;
  303|      0|    }
  304|  8.51k|}
_ZN11xercesc_3_212IGXMLScanner10commonInitEv:
  508|  8.51k|{
  509|       |
  510|       |    //  Create the element state array
  511|  8.51k|    fElemState = (unsigned int*) fMemoryManager->allocate
  512|  8.51k|    (
  513|  8.51k|        fElemStateSize * sizeof(unsigned int)
  514|  8.51k|    ); //new unsigned int[fElemStateSize];
  515|  8.51k|    fElemLoopState = (unsigned int*) fMemoryManager->allocate
  516|  8.51k|    (
  517|  8.51k|        fElemStateSize * sizeof(unsigned int)
  518|  8.51k|    ); //new unsigned int[fElemStateSize];
  519|       |
  520|       |    //  And we need one for the raw attribute scan. This just stores key/
  521|       |    //  value string pairs (prior to any processing.)
  522|  8.51k|    fRawAttrList = new (fMemoryManager) RefVectorOf<KVStringPair>(32, true, fMemoryManager);
  523|  8.51k|    fRawAttrColonList = (int*) fMemoryManager->allocate
  524|  8.51k|    (
  525|  8.51k|        fRawAttrColonListSize * sizeof(int)
  526|  8.51k|    );
  527|       |
  528|       |    //  Create the Validator and init them
  529|  8.51k|    fDTDValidator = new (fMemoryManager) DTDValidator();
  530|  8.51k|    initValidator(fDTDValidator);
  531|  8.51k|    fSchemaValidator = new (fMemoryManager) SchemaValidator(0, fMemoryManager);
  532|  8.51k|    initValidator(fSchemaValidator);
  533|       |
  534|       |    // Create IdentityConstraint info
  535|  8.51k|    fICHandler = new (fMemoryManager) IdentityConstraintHandler(this, fMemoryManager);
  536|       |
  537|       |    // Create schemaLocation pair info
  538|  8.51k|    fLocationPairs = new (fMemoryManager) ValueVectorOf<XMLCh*>(8, fMemoryManager);
  539|       |    // create pools for undeclared elements
  540|  8.51k|    fDTDElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
  541|  8.51k|    fSchemaElemNonDeclPool = new (fMemoryManager) RefHash3KeysIdPool<SchemaElementDecl>(29, true, 128, fMemoryManager);
  542|  8.51k|    fAttDefRegistry = new (fMemoryManager) RefHashTableOf<unsigned int, PtrHasher>
  543|  8.51k|    (
  544|  8.51k|        131, false, fMemoryManager
  545|  8.51k|    );
  546|  8.51k|    fUndeclaredAttrRegistry = new (fMemoryManager) Hash2KeysSetOf<StringHasher>(7, fMemoryManager);
  547|  8.51k|    fPSVIAttrList = new (fMemoryManager) PSVIAttributeList(fMemoryManager);
  548|       |
  549|  8.51k|    fSchemaInfoList = new (fMemoryManager) RefHash2KeysTableOf<SchemaInfo>(29, fMemoryManager);
  550|  8.51k|    fCachedSchemaInfoList = new (fMemoryManager) RefHash2KeysTableOf<SchemaInfo>(29, fMemoryManager);
  551|       |
  552|       |    // use fDTDValidator as the default validator
  553|  8.51k|    if (!fValidator)
  ------------------
  |  Branch (553:9): [True: 8.51k, False: 0]
  ------------------
  554|  8.51k|        fValidator = fDTDValidator;
  555|  8.51k|}
_ZN11xercesc_3_212IGXMLScanner7cleanUpEv:
  558|  8.51k|{
  559|  8.51k|    fMemoryManager->deallocate(fElemState); //delete [] fElemState;
  560|  8.51k|    fMemoryManager->deallocate(fElemLoopState); //delete [] fElemLoopState;
  561|  8.51k|    delete fRawAttrList;
  562|  8.51k|    fMemoryManager->deallocate(fRawAttrColonList);
  563|  8.51k|    delete fDTDValidator;
  564|  8.51k|    delete fSchemaValidator;
  565|  8.51k|    delete fICHandler;
  566|  8.51k|    delete fLocationPairs;
  567|  8.51k|    delete fDTDElemNonDeclPool;
  568|  8.51k|    delete fSchemaElemNonDeclPool;
  569|  8.51k|    delete fAttDefRegistry;
  570|  8.51k|    delete fUndeclaredAttrRegistry;
  571|  8.51k|    delete fPSVIAttrList;
  572|  8.51k|    delete fPSVIElement;
  573|  8.51k|    delete fErrorStack;
  574|  8.51k|    delete fSchemaInfoList;
  575|  8.51k|    delete fCachedSchemaInfoList;
  576|  8.51k|}
_ZN11xercesc_3_212IGXMLScanner11scanContentEv:
  811|  3.88k|{
  812|       |    //  Go into a loop until we hit the end of the root element, or we fall
  813|       |    //  out because there is no root element.
  814|       |    //
  815|       |    //  We have to do kind of a deeply nested double loop here in order to
  816|       |    //  avoid doing the setup/teardown of the exception handler on each
  817|       |    //  round. Doing it this way we only do it when an exception actually
  818|       |    //  occurs.
  819|  3.88k|    bool gotData = true;
  820|  3.88k|    bool inMarkup = false;
  821|  10.7k|    while (gotData)
  ------------------
  |  Branch (821:12): [True: 9.33k, False: 1.42k]
  ------------------
  822|  9.33k|    {
  823|  9.33k|        try
  824|  9.33k|        {
  825|  1.40M|            while (gotData)
  ------------------
  |  Branch (825:20): [True: 1.39M, False: 3.23k]
  ------------------
  826|  1.39M|            {
  827|       |                //  Sense what the next top level token is. According to what
  828|       |                //  this tells us, we will call something to handle that kind
  829|       |                //  of thing.
  830|  1.39M|                XMLSize_t orgReader;
  831|  1.39M|                const XMLTokens curToken = senseNextToken(orgReader);
  832|       |
  833|       |                //  Handle character data and end of file specially. Char data
  834|       |                //  is not markup so we don't want to handle it in the loop
  835|       |                //  below.
  836|  1.39M|                if (curToken == Token_CharData)
  ------------------
  |  Branch (836:21): [True: 688k, False: 709k]
  ------------------
  837|   688k|                {
  838|       |                    //  Scan the character data and call appropriate events. Let
  839|       |                    //  him use our local character data buffer for efficiency.
  840|   688k|                    scanCharData(fCDataBuf);
  841|   688k|                    continue;
  842|   688k|                }
  843|   709k|                else if (curToken == Token_EOF)
  ------------------
  |  Branch (843:26): [True: 1.23k, False: 708k]
  ------------------
  844|  1.23k|                {
  845|       |                    //  The element stack better be empty at this point or we
  846|       |                    //  ended prematurely before all elements were closed.
  847|  1.23k|                    if (!fElemStack.isEmpty())
  ------------------
  |  Branch (847:25): [True: 1.23k, False: 0]
  ------------------
  848|  1.23k|                    {
  849|  1.23k|                        const ElemStack::StackElem* topElem = fElemStack.popTop();
  850|  1.23k|                        emitError
  851|  1.23k|                        (
  852|  1.23k|                            XMLErrs::EndedWithTagsOnStack
  853|  1.23k|                            , topElem->fThisElement->getFullName()
  854|  1.23k|                        );
  855|  1.23k|                    }
  856|       |
  857|       |                    // Its the end of file, so clear the got data flag
  858|  1.23k|                    gotData = false;
  859|  1.23k|                    continue;
  860|  1.23k|                }
  861|       |
  862|       |                // We are in some sort of markup now
  863|   708k|                inMarkup = true;
  864|       |
  865|       |                //  According to the token we got, call the appropriate
  866|       |                //  scanning method.
  867|   708k|                switch(curToken)
  868|   708k|                {
  869|  1.37k|                    case Token_CData :
  ------------------
  |  Branch (869:21): [True: 1.37k, False: 707k]
  ------------------
  870|       |                        // Make sure we are within content
  871|  1.37k|                        if (fElemStack.isEmpty())
  ------------------
  |  Branch (871:29): [True: 0, False: 1.37k]
  ------------------
  872|      0|                            emitError(XMLErrs::CDATAOutsideOfContent);
  873|  1.37k|                        scanCDSection();
  874|  1.37k|                        break;
  875|       |
  876|    302|                    case Token_Comment :
  ------------------
  |  Branch (876:21): [True: 302, False: 708k]
  ------------------
  877|    302|                        scanComment();
  878|    302|                        break;
  879|       |
  880|   136k|                    case Token_EndTag :
  ------------------
  |  Branch (880:21): [True: 136k, False: 572k]
  ------------------
  881|   136k|                        scanEndTag(gotData);
  882|   136k|                        break;
  883|       |
  884|  6.39k|                    case Token_PI :
  ------------------
  |  Branch (884:21): [True: 6.39k, False: 702k]
  ------------------
  885|  6.39k|                        scanPI();
  886|  6.39k|                        break;
  887|       |
  888|   558k|                    case Token_StartTag :
  ------------------
  |  Branch (888:21): [True: 558k, False: 149k]
  ------------------
  889|   558k|                        if (fDoNamespaces)
  ------------------
  |  Branch (889:29): [True: 0, False: 558k]
  ------------------
  890|      0|                            scanStartTagNS(gotData);
  891|   558k|                        else
  892|   558k|                            scanStartTag(gotData);
  893|   558k|                        break;
  894|       |
  895|      0|                    default :
  ------------------
  |  Branch (895:21): [True: 0, False: 708k]
  ------------------
  896|      0|                        fReaderMgr.skipToChar(chOpenAngle);
  897|      0|                        break;
  898|   708k|                }
  899|       |
  900|   702k|                if (orgReader != fReaderMgr.getCurrentReaderNum())
  ------------------
  |  Branch (900:21): [True: 3, False: 702k]
  ------------------
  901|      3|                    emitError(XMLErrs::PartialMarkupInEntity);
  902|       |
  903|       |                // And we are back out of markup again
  904|   702k|                inMarkup = false;
  905|   702k|            }
  906|  9.33k|        }
  907|  9.33k|        catch(const EndOfEntityException& toCatch)
  908|  9.33k|        {
  909|       |            //  If we were in some markup when this happened, then its a
  910|       |            //  partial markup error.
  911|  5.45k|            if (inMarkup)
  ------------------
  |  Branch (911:17): [True: 0, False: 5.45k]
  ------------------
  912|      0|                emitError(XMLErrs::PartialMarkupInEntity);
  913|       |
  914|       |            // Send an end of entity reference event
  915|  5.45k|            if (fDocHandler)
  ------------------
  |  Branch (915:17): [True: 0, False: 5.45k]
  ------------------
  916|      0|                fDocHandler->endEntityReference(toCatch.getEntity());
  917|       |
  918|  5.45k|            inMarkup = false;
  919|  5.45k|        }
  920|  9.33k|    }
  921|       |
  922|       |    // It went ok, so return success
  923|  1.42k|    return true;
  924|  3.88k|}
_ZN11xercesc_3_212IGXMLScanner10scanEndTagERb:
  928|   136k|{
  929|       |    //  Assume we will still have data until proven otherwise. It will only
  930|       |    //  ever be false if this is the end of the root element.
  931|   136k|    gotData = true;
  932|       |
  933|       |    //  Check if the element stack is empty. If so, then this is an unbalanced
  934|       |    //  element (i.e. more ends than starts, perhaps because of bad text
  935|       |    //  causing one to be skipped.)
  936|   136k|    if (fElemStack.isEmpty())
  ------------------
  |  Branch (936:9): [True: 1, False: 136k]
  ------------------
  937|      1|    {
  938|      1|        emitError(XMLErrs::MoreEndThanStartTags);
  939|      1|        fReaderMgr.skipPastChar(chCloseAngle);
  940|      1|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Scan_UnbalancedStartEnd, fMemoryManager);
  ------------------
  |  |  264|      1|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  941|      1|    }
  942|       |
  943|       |    //  Pop the stack of the element we are supposed to be ending. Remember
  944|       |    //  that we don't own this. The stack just keeps them and reuses them.
  945|   136k|    unsigned int uriId = (fDoNamespaces)
  ------------------
  |  Branch (945:26): [True: 0, False: 136k]
  ------------------
  946|   136k|        ? fElemStack.getCurrentURI() : fEmptyNamespaceId;
  947|       |
  948|       |    // these get initialized below
  949|   136k|    const ElemStack::StackElem* topElem = 0;
  950|   136k|    const XMLCh *elemName = 0;
  951|       |
  952|       |    // Make sure that its the end of the element that we expect
  953|       |    // special case for schema validation, whose element decls,
  954|       |    // obviously don't contain prefix information
  955|   136k|    if(fGrammarType == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (955:8): [True: 0, False: 136k]
  ------------------
  956|      0|    {
  957|      0|        elemName = fElemStack.getCurrentSchemaElemName();
  958|      0|        topElem = fElemStack.topElement();
  959|      0|    }
  960|   136k|    else
  961|   136k|    {
  962|   136k|        topElem = fElemStack.topElement();
  963|   136k|        elemName = topElem->fThisElement->getFullName();
  964|   136k|    }
  965|   136k|    if (!fReaderMgr.skippedStringLong(elemName))
  ------------------
  |  Branch (965:9): [True: 98, False: 136k]
  ------------------
  966|     98|    {
  967|     98|        emitError
  968|     98|        (
  969|     98|            XMLErrs::ExpectedEndOfTagX
  970|     98|            , elemName
  971|     98|        );
  972|     98|        fReaderMgr.skipPastChar(chCloseAngle);
  973|     98|        fElemStack.popTop();
  974|     98|        return;
  975|     98|    }
  976|       |
  977|       |    // Make sure we are back on the same reader as where we started
  978|   136k|    if (topElem->fReaderNum != fReaderMgr.getCurrentReaderNum())
  ------------------
  |  Branch (978:9): [True: 1, False: 136k]
  ------------------
  979|      1|        emitError(XMLErrs::PartialTagMarkupError);
  980|       |
  981|       |    // Skip optional whitespace
  982|   136k|    fReaderMgr.skipPastSpaces();
  983|       |
  984|       |    // Make sure we find the closing bracket
  985|   136k|    if (!fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (985:9): [True: 11, False: 136k]
  ------------------
  986|     11|    {
  987|     11|        emitError
  988|     11|        (
  989|     11|            XMLErrs::UnterminatedEndTag
  990|     11|            , topElem->fThisElement->getFullName()
  991|     11|        );
  992|     11|    }
  993|       |
  994|   136k|    if (fGrammarType == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (994:9): [True: 0, False: 136k]
  ------------------
  995|      0|    {
  996|       |        // reset error occurred
  997|      0|        fPSVIElemContext.fErrorOccurred = fErrorStack->pop();
  998|      0|        if (fValidate && topElem->fThisElement->isDeclared())
  ------------------
  |  Branch (998:13): [True: 0, False: 0]
  |  Branch (998:26): [True: 0, False: 0]
  ------------------
  999|      0|        {
 1000|      0|            fPSVIElemContext.fCurrentTypeInfo = ((SchemaValidator*) fValidator)->getCurrentTypeInfo();
 1001|      0|            if(!fPSVIElemContext.fCurrentTypeInfo)
  ------------------
  |  Branch (1001:16): [True: 0, False: 0]
  ------------------
 1002|      0|                fPSVIElemContext.fCurrentDV = ((SchemaValidator*) fValidator)->getCurrentDatatypeValidator();
 1003|      0|            else
 1004|      0|                fPSVIElemContext.fCurrentDV = 0;
 1005|      0|            if(fPSVIHandler)
  ------------------
  |  Branch (1005:16): [True: 0, False: 0]
  ------------------
 1006|      0|            {
 1007|      0|                fPSVIElemContext.fNormalizedValue = ((SchemaValidator*) fValidator)->getNormalizedValue();
 1008|       |
 1009|      0|                if (XMLString::equals(fPSVIElemContext.fNormalizedValue, XMLUni::fgZeroLenString))
  ------------------
  |  Branch (1009:21): [True: 0, False: 0]
  ------------------
 1010|      0|                    fPSVIElemContext.fNormalizedValue = 0;
 1011|      0|            }
 1012|      0|        }
 1013|      0|        else
 1014|      0|        {
 1015|      0|            fPSVIElemContext.fCurrentDV = 0;
 1016|      0|            fPSVIElemContext.fCurrentTypeInfo = 0;
 1017|      0|            fPSVIElemContext.fNormalizedValue = 0;
 1018|      0|        }
 1019|      0|    }
 1020|       |
 1021|       |    //  If validation is enabled, then lets pass him the list of children and
 1022|       |    //  this element and let him validate it.
 1023|   136k|    DatatypeValidator* psviMemberType = 0;
 1024|   136k|    if (fValidate)
  ------------------
  |  Branch (1024:9): [True: 136k, False: 18]
  ------------------
 1025|   136k|    {
 1026|       |
 1027|       |       //
 1028|       |       // XML1.0-3rd
 1029|       |       // Validity Constraint:
 1030|       |       // The declaration matches EMPTY and the element has no content (not even
 1031|       |       // entity references, comments, PIs or white space).
 1032|       |       //
 1033|   136k|       if ( (fGrammarType == Grammar::DTDGrammarType) &&
  ------------------
  |  Branch (1033:13): [True: 136k, False: 0]
  ------------------
 1034|   136k|            (topElem->fCommentOrPISeen)               &&
  ------------------
  |  Branch (1034:13): [True: 2.48k, False: 133k]
  ------------------
 1035|   136k|            (((DTDElementDecl*) topElem->fThisElement)->getModelType() == DTDElementDecl::Empty))
  ------------------
  |  Branch (1035:13): [True: 198, False: 2.28k]
  ------------------
 1036|    198|       {
 1037|    198|           fValidator->emitError
 1038|    198|               (
 1039|    198|               XMLValid::EmptyElemHasContent
 1040|    198|               , topElem->fThisElement->getFullName()
 1041|    198|               );
 1042|    198|       }
 1043|       |
 1044|       |       //
 1045|       |       // XML1.0-3rd
 1046|       |       // Validity Constraint:
 1047|       |       //
 1048|       |       // The declaration matches children and the sequence of child elements
 1049|       |       // belongs to the language generated by the regular expression in the
 1050|       |       // content model, with optional white space, comments and PIs
 1051|       |       // (i.e. markup matching production [27] Misc) between the start-tag and
 1052|       |       // the first child element, between child elements, or between the last
 1053|       |       // child element and the end-tag.
 1054|       |       //
 1055|       |       // Note that
 1056|       |       //    a CDATA section containing only white space or
 1057|       |       //    a reference to an entity whose replacement text is character references
 1058|       |       //       expanding to white space do not match the nonterminal S, and hence
 1059|       |       //       cannot appear in these positions; however,
 1060|       |       //    a reference to an internal entity with a literal value consisting
 1061|       |       //       of character references expanding to white space does match S,
 1062|       |       //       since its replacement text is the white space resulting from expansion
 1063|       |       //       of the character references.
 1064|       |       //
 1065|   136k|       if ( (fGrammarType == Grammar::DTDGrammarType)  &&
  ------------------
  |  Branch (1065:13): [True: 136k, False: 0]
  ------------------
 1066|   136k|            (topElem->fReferenceEscaped)               &&
  ------------------
  |  Branch (1066:13): [True: 435, False: 135k]
  ------------------
 1067|   136k|            (((DTDElementDecl*) topElem->fThisElement)->getModelType() == DTDElementDecl::Children))
  ------------------
  |  Branch (1067:13): [True: 202, False: 233]
  ------------------
 1068|    202|       {
 1069|    202|           fValidator->emitError
 1070|    202|               (
 1071|    202|               XMLValid::ElemChildrenHasInvalidWS
 1072|    202|               , topElem->fThisElement->getFullName()
 1073|    202|               );
 1074|    202|       }
 1075|   136k|        XMLSize_t failure;
 1076|   136k|        bool res = fValidator->checkContent
 1077|   136k|        (
 1078|   136k|            topElem->fThisElement
 1079|   136k|            , topElem->fChildren
 1080|   136k|            , topElem->fChildCount
 1081|   136k|            , &failure
 1082|   136k|        );
 1083|       |
 1084|   136k|        if (!res)
  ------------------
  |  Branch (1084:13): [True: 9.25k, False: 126k]
  ------------------
 1085|  9.25k|        {
 1086|       |            //  One of the elements is not valid for the content. NOTE that
 1087|       |            //  if no children were provided but the content model requires
 1088|       |            //  them, it comes back with a zero value. But we cannot use that
 1089|       |            //  to index the child array in this case, and have to put out a
 1090|       |            //  special message.
 1091|  9.25k|            if (!topElem->fChildCount)
  ------------------
  |  Branch (1091:17): [True: 1.21k, False: 8.03k]
  ------------------
 1092|  1.21k|            {
 1093|  1.21k|                fValidator->emitError
 1094|  1.21k|                (
 1095|  1.21k|                    XMLValid::EmptyNotValidForContent
 1096|  1.21k|                    , topElem->fThisElement->getFormattedContentModel()
 1097|  1.21k|                );
 1098|  1.21k|            }
 1099|  8.03k|            else if (failure >= topElem->fChildCount)
  ------------------
  |  Branch (1099:22): [True: 1.18k, False: 6.85k]
  ------------------
 1100|  1.18k|            {
 1101|  1.18k|                fValidator->emitError
 1102|  1.18k|                (
 1103|  1.18k|                    XMLValid::NotEnoughElemsForCM
 1104|  1.18k|                    , topElem->fThisElement->getFormattedContentModel()
 1105|  1.18k|                );
 1106|  1.18k|            }
 1107|  6.85k|            else
 1108|  6.85k|            {
 1109|  6.85k|                fValidator->emitError
 1110|  6.85k|                (
 1111|  6.85k|                    XMLValid::ElementNotValidForContent
 1112|  6.85k|                    , topElem->fChildren[failure]->getRawName()
 1113|  6.85k|                    , topElem->fThisElement->getFormattedContentModel()
 1114|  6.85k|                );
 1115|  6.85k|            }
 1116|  9.25k|        }
 1117|       |
 1118|       |
 1119|   136k|        if (fGrammarType == Grammar::SchemaGrammarType) {
  ------------------
  |  Branch (1119:13): [True: 0, False: 136k]
  ------------------
 1120|      0|            if (((SchemaValidator*) fValidator)->getErrorOccurred())
  ------------------
  |  Branch (1120:17): [True: 0, False: 0]
  ------------------
 1121|      0|                fPSVIElemContext.fErrorOccurred = true;
 1122|      0|            else if (fPSVIElemContext.fCurrentDV && fPSVIElemContext.fCurrentDV->getType() == DatatypeValidator::Union)
  ------------------
  |  Branch (1122:22): [True: 0, False: 0]
  |  Branch (1122:53): [True: 0, False: 0]
  ------------------
 1123|      0|                psviMemberType = fValidationContext->getValidatingMemberType();
 1124|       |
 1125|      0|            if (fPSVIHandler)
  ------------------
  |  Branch (1125:17): [True: 0, False: 0]
  ------------------
 1126|      0|            {
 1127|      0|                fPSVIElemContext.fIsSpecified = ((SchemaValidator*) fValidator)->getIsElemSpecified();
 1128|      0|                if(fPSVIElemContext.fIsSpecified)
  ------------------
  |  Branch (1128:20): [True: 0, False: 0]
  ------------------
 1129|      0|                    fPSVIElemContext.fNormalizedValue = ((SchemaElementDecl *)topElem->fThisElement)->getDefaultValue();
 1130|      0|            }
 1131|       |
 1132|       |            // call matchers and de-activate context
 1133|      0|            if (toCheckIdentityConstraint())
  ------------------
  |  Branch (1133:17): [True: 0, False: 0]
  ------------------
 1134|      0|            {
 1135|      0|                fICHandler->deactivateContext
 1136|      0|                             (
 1137|      0|                              (SchemaElementDecl *) topElem->fThisElement
 1138|      0|                            , fContent.getRawBuffer()
 1139|      0|                            , fValidationContext
 1140|      0|                            , fPSVIElemContext.fCurrentDV
 1141|      0|                             );
 1142|      0|            }
 1143|       |
 1144|      0|        }
 1145|   136k|    }
 1146|       |
 1147|       |    // QName dv needed topElem to resolve URIs on the checkContent
 1148|   136k|    fElemStack.popTop();
 1149|       |
 1150|       |    // See if it was the root element, to avoid multiple calls below
 1151|   136k|    const bool isRoot = fElemStack.isEmpty();
 1152|       |
 1153|   136k|    if (fGrammarType == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (1153:9): [True: 0, False: 136k]
  ------------------
 1154|      0|    {
 1155|      0|        if (fPSVIHandler)
  ------------------
  |  Branch (1155:13): [True: 0, False: 0]
  ------------------
 1156|      0|        {
 1157|      0|            endElementPSVI(
 1158|      0|                (SchemaElementDecl*)topElem->fThisElement, psviMemberType);
 1159|      0|        }
 1160|       |        // now we can reset the datatype buffer, since the
 1161|       |        // application has had a chance to copy the characters somewhere else
 1162|      0|        ((SchemaValidator *)fValidator)->clearDatatypeBuffer();
 1163|      0|    }
 1164|       |
 1165|       |    // If we have a doc handler, tell it about the end tag
 1166|   136k|    if (fDocHandler)
  ------------------
  |  Branch (1166:9): [True: 0, False: 136k]
  ------------------
 1167|      0|    {
 1168|      0|        if (fGrammarType == Grammar::SchemaGrammarType) {
  ------------------
  |  Branch (1168:13): [True: 0, False: 0]
  ------------------
 1169|      0|            if (topElem->fPrefixColonPos != -1)
  ------------------
  |  Branch (1169:17): [True: 0, False: 0]
  ------------------
 1170|      0|                fPrefixBuf.set(elemName, topElem->fPrefixColonPos);
 1171|      0|            else
 1172|      0|                fPrefixBuf.reset();
 1173|      0|        }
 1174|      0|        else {
 1175|      0|            fPrefixBuf.set(topElem->fThisElement->getElementName()->getPrefix());
 1176|      0|        }
 1177|      0|        fDocHandler->endElement
 1178|      0|        (
 1179|      0|            *topElem->fThisElement
 1180|      0|            , uriId
 1181|      0|            , isRoot
 1182|      0|            , fPrefixBuf.getRawBuffer()
 1183|      0|        );
 1184|      0|    }
 1185|       |
 1186|   136k|    if (fGrammarType == Grammar::SchemaGrammarType) {
  ------------------
  |  Branch (1186:9): [True: 0, False: 136k]
  ------------------
 1187|      0|        if (!isRoot)
  ------------------
  |  Branch (1187:13): [True: 0, False: 0]
  ------------------
 1188|      0|        {
 1189|       |            // update error information
 1190|      0|            fErrorStack->push((fErrorStack->size() && fErrorStack->pop()) || fPSVIElemContext.fErrorOccurred);
  ------------------
  |  Branch (1190:32): [True: 0, False: 0]
  |  Branch (1190:55): [True: 0, False: 0]
  |  Branch (1190:78): [True: 0, False: 0]
  ------------------
 1191|       |
 1192|       |
 1193|      0|        }
 1194|      0|    }
 1195|       |
 1196|       |    // If this was the root, then done with content
 1197|   136k|    gotData = !isRoot;
 1198|       |
 1199|   136k|    if (gotData) {
  ------------------
  |  Branch (1199:9): [True: 135k, False: 467]
  ------------------
 1200|   135k|        if (fDoNamespaces) {
  ------------------
  |  Branch (1200:13): [True: 0, False: 135k]
  ------------------
 1201|       |            // Restore the grammar
 1202|      0|            fGrammar = fElemStack.getCurrentGrammar();
 1203|      0|            fGrammarType = fGrammar->getGrammarType();
 1204|      0|            if (fGrammarType == Grammar::SchemaGrammarType && !fValidator->handlesSchema()) {
  ------------------
  |  Branch (1204:17): [True: 0, False: 0]
  |  Branch (1204:63): [True: 0, False: 0]
  ------------------
 1205|      0|                if (fValidatorFromUser)
  ------------------
  |  Branch (1205:21): [True: 0, False: 0]
  ------------------
 1206|      0|                    ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Gen_NoSchemaValidator, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1207|      0|                else {
 1208|      0|                    fValidator = fSchemaValidator;
 1209|      0|                }
 1210|      0|            }
 1211|      0|            else if (fGrammarType == Grammar::DTDGrammarType && !fValidator->handlesDTD()) {
  ------------------
  |  Branch (1211:22): [True: 0, False: 0]
  |  Branch (1211:65): [True: 0, False: 0]
  ------------------
 1212|      0|                if (fValidatorFromUser)
  ------------------
  |  Branch (1212:21): [True: 0, False: 0]
  ------------------
 1213|      0|                    ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Gen_NoDTDValidator, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1214|      0|                else {
 1215|      0|                    fValidator = fDTDValidator;
 1216|      0|                }
 1217|      0|            }
 1218|       |
 1219|      0|            fValidator->setGrammar(fGrammar);
 1220|      0|        }
 1221|       |
 1222|       |        // Restore the validation flag
 1223|   135k|        fValidate = fElemStack.getValidationFlag();
 1224|   135k|    }
 1225|   136k|}
_ZN11xercesc_3_212IGXMLScanner15scanDocTypeDeclEv:
 1235|  8.31k|{
 1236|       |    //  We have a doc type. So, switch the Grammar.
 1237|  8.31k|    switchGrammar(XMLUni::fgDTDEntityString);
 1238|       |
 1239|  8.31k|    if (fDocTypeHandler)
  ------------------
  |  Branch (1239:9): [True: 0, False: 8.31k]
  ------------------
 1240|      0|        fDocTypeHandler->resetDocType();
 1241|       |
 1242|       |    // There must be some space after DOCTYPE
 1243|  8.31k|    bool skippedSomething;
 1244|  8.31k|    fReaderMgr.skipPastSpaces(skippedSomething);
 1245|  8.31k|    if (!skippedSomething)
  ------------------
  |  Branch (1245:9): [True: 0, False: 8.31k]
  ------------------
 1246|      0|    {
 1247|      0|        emitError(XMLErrs::ExpectedWhitespace);
 1248|       |
 1249|       |        // Just skip the Doctype declaration and return
 1250|      0|        fReaderMgr.skipPastChar(chCloseAngle);
 1251|      0|        return;
 1252|      0|    }
 1253|       |
 1254|       |    // Get a buffer for the root element
 1255|  8.31k|    XMLBufBid bbRootName(&fBufMgr);
 1256|       |
 1257|       |    //  Get a name from the input, which should be the name of the root
 1258|       |    //  element of the upcoming content.
 1259|  8.31k|    int  colonPosition;
 1260|  8.31k|    bool validName = fDoNamespaces ? fReaderMgr.getQName(bbRootName.getBuffer(), &colonPosition) :
  ------------------
  |  Branch (1260:22): [True: 0, False: 8.31k]
  ------------------
 1261|  8.31k|                                     fReaderMgr.getName(bbRootName.getBuffer());
 1262|  8.31k|    if (!validName)
  ------------------
  |  Branch (1262:9): [True: 11, False: 8.30k]
  ------------------
 1263|     11|    {
 1264|     11|        if (bbRootName.isEmpty())
  ------------------
  |  Branch (1264:13): [True: 11, False: 0]
  ------------------
 1265|     11|            emitError(XMLErrs::NoRootElemInDOCTYPE);
 1266|      0|        else
 1267|      0|            emitError(XMLErrs::InvalidRootElemInDOCTYPE, bbRootName.getRawBuffer());
 1268|     11|        fReaderMgr.skipPastChar(chCloseAngle);
 1269|     11|        return;
 1270|     11|    }
 1271|       |
 1272|       |    //  Store the root element name for later check
 1273|  8.30k|    setRootElemName(bbRootName.getRawBuffer());
 1274|       |
 1275|       |    //  This element obviously is not going to exist in the element decl
 1276|       |    //  pool yet, but we need to call docTypeDecl. So force it into
 1277|       |    //  the element decl pool, marked as being there because it was in
 1278|       |    //  the DOCTYPE. Later, when its declared, the status will be updated.
 1279|       |    //
 1280|       |    //  Only do this if we are not reusing the validator! If we are reusing,
 1281|       |    //  then look it up instead. It has to exist!
 1282|  8.30k|    MemoryManager* const  rootDeclMgr =
 1283|  8.30k|        fUseCachedGrammar ? fMemoryManager : fGrammarPoolMemoryManager;
  ------------------
  |  Branch (1283:9): [True: 0, False: 8.30k]
  ------------------
 1284|       |
 1285|  8.30k|    DTDElementDecl* rootDecl = new (rootDeclMgr) DTDElementDecl
 1286|  8.30k|    (
 1287|  8.30k|        bbRootName.getRawBuffer()
 1288|  8.30k|        , fEmptyNamespaceId
 1289|  8.30k|        , DTDElementDecl::Any
 1290|  8.30k|        , rootDeclMgr
 1291|  8.30k|    );
 1292|       |
 1293|  8.30k|    Janitor<DTDElementDecl> rootDeclJanitor(rootDecl);
 1294|  8.30k|    rootDecl->setCreateReason(DTDElementDecl::AsRootElem);
 1295|  8.30k|    rootDecl->setExternalElemDeclaration(true);
 1296|  8.30k|    if(!fUseCachedGrammar)
  ------------------
  |  Branch (1296:8): [True: 8.30k, False: 0]
  ------------------
 1297|  8.30k|    {
 1298|  8.30k|        fGrammar->putElemDecl(rootDecl);
 1299|  8.30k|        rootDeclJanitor.release();
 1300|  8.30k|    } else
 1301|      0|    {
 1302|       |        // attach this to the undeclared element pool so that it gets deleted
 1303|      0|        XMLElementDecl* elemDecl = fDTDElemNonDeclPool->getByKey(bbRootName.getRawBuffer());
 1304|      0|        if (elemDecl)
  ------------------
  |  Branch (1304:13): [True: 0, False: 0]
  ------------------
 1305|      0|        {
 1306|      0|            rootDecl->setId(elemDecl->getId());
 1307|      0|        }
 1308|      0|        else
 1309|      0|        {
 1310|      0|            rootDecl->setId(fDTDElemNonDeclPool->put((DTDElementDecl*)rootDecl));
 1311|      0|            rootDeclJanitor.release();
 1312|      0|        }
 1313|      0|    }
 1314|       |
 1315|       |    // Skip any spaces after the name
 1316|  8.30k|    fReaderMgr.skipPastSpaces();
 1317|       |
 1318|       |    //  And now if we are looking at a >, then we are done. It is not
 1319|       |    //  required to have an internal or external subset, though why you
 1320|       |    //  would not escapes me.
 1321|  8.30k|    if (fReaderMgr.skippedChar(chCloseAngle)) {
  ------------------
  |  Branch (1321:9): [True: 0, False: 8.30k]
  ------------------
 1322|       |
 1323|       |        //  If we have a doc type handler and advanced callbacks are enabled,
 1324|       |        //  call the doctype event.
 1325|      0|        if (fDocTypeHandler)
  ------------------
  |  Branch (1325:13): [True: 0, False: 0]
  ------------------
 1326|      0|            fDocTypeHandler->doctypeDecl(*rootDecl, 0, 0, false);
 1327|      0|        return;
 1328|      0|    }
 1329|       |
 1330|       |    // either internal/external subset
 1331|  8.30k|    if (fValScheme == Val_Auto && !fValidate)
  ------------------
  |  Branch (1331:9): [True: 8.30k, False: 1]
  |  Branch (1331:35): [True: 8.30k, False: 0]
  ------------------
 1332|  8.30k|        fValidate = true;
 1333|       |
 1334|  8.30k|    bool    hasIntSubset = false;
 1335|  8.30k|    bool    hasExtSubset = false;
 1336|  8.30k|    XMLCh*  sysId = 0;
 1337|  8.30k|    XMLCh*  pubId = 0;
 1338|       |
 1339|  8.30k|    DTDScanner dtdScanner
 1340|  8.30k|    (
 1341|  8.30k|        (DTDGrammar*) fGrammar
 1342|  8.30k|        , fDocTypeHandler
 1343|  8.30k|        , fGrammarPoolMemoryManager
 1344|  8.30k|        , fMemoryManager
 1345|  8.30k|    );
 1346|  8.30k|    dtdScanner.setScannerInfo(this, &fReaderMgr, &fBufMgr);
 1347|       |
 1348|       |    //  If the next character is '[' then we have no external subset cause
 1349|       |    //  there is no system id, just the opening character of the internal
 1350|       |    //  subset. Else, has to be an id.
 1351|       |    //
 1352|       |    // Just look at the next char, don't eat it.
 1353|  8.30k|    if (fReaderMgr.peekNextChar() == chOpenSquare)
  ------------------
  |  Branch (1353:9): [True: 673, False: 7.63k]
  ------------------
 1354|    673|    {
 1355|    673|        hasIntSubset = true;
 1356|    673|    }
 1357|  7.63k|    else
 1358|  7.63k|    {
 1359|       |        // Indicate we have an external subset
 1360|  7.63k|        hasExtSubset = true;
 1361|  7.63k|        fHasNoDTD = false;
 1362|       |
 1363|       |        // Get buffers for the ids
 1364|  7.63k|        XMLBufBid bbPubId(&fBufMgr);
 1365|  7.63k|        XMLBufBid bbSysId(&fBufMgr);
 1366|       |
 1367|       |        // Get the external subset id
 1368|  7.63k|        if (!dtdScanner.scanId(bbPubId.getBuffer(), bbSysId.getBuffer(), DTDScanner::IDType_External))
  ------------------
  |  Branch (1368:13): [True: 0, False: 7.63k]
  ------------------
 1369|      0|        {
 1370|      0|            fReaderMgr.skipPastChar(chCloseAngle);
 1371|      0|            return;
 1372|      0|        }
 1373|       |
 1374|       |        // Get copies of the ids we got
 1375|  7.63k|        pubId = XMLString::replicate(bbPubId.getRawBuffer(), fMemoryManager);
 1376|  7.63k|        sysId = XMLString::replicate(bbSysId.getRawBuffer(), fMemoryManager);
 1377|       |
 1378|       |        // Skip spaces and check again for the opening of an internal subset
 1379|  7.63k|        fReaderMgr.skipPastSpaces();
 1380|       |
 1381|       |        // Just look at the next char, don't eat it.
 1382|  7.63k|        if (fReaderMgr.peekNextChar() == chOpenSquare) {
  ------------------
  |  Branch (1382:13): [True: 7.61k, False: 22]
  ------------------
 1383|  7.61k|            hasIntSubset = true;
 1384|  7.61k|        }
 1385|  7.63k|    }
 1386|       |
 1387|       |    // Insure that the ids get cleaned up, if they got allocated
 1388|  8.30k|    ArrayJanitor<XMLCh> janSysId(sysId, fMemoryManager);
 1389|  8.30k|    ArrayJanitor<XMLCh> janPubId(pubId, fMemoryManager);
 1390|       |
 1391|       |    //  If we have a doc type handler and advanced callbacks are enabled,
 1392|       |    //  call the doctype event.
 1393|  8.30k|    if (fDocTypeHandler)
  ------------------
  |  Branch (1393:9): [True: 0, False: 8.30k]
  ------------------
 1394|      0|        fDocTypeHandler->doctypeDecl(*rootDecl, pubId, sysId, hasIntSubset, hasExtSubset);
 1395|       |
 1396|       |    //  Ok, if we had an internal subset, we are just past the [ character
 1397|       |    //  and need to parse that first.
 1398|  8.30k|    if (hasIntSubset)
  ------------------
  |  Branch (1398:9): [True: 8.28k, False: 22]
  ------------------
 1399|  8.28k|    {
 1400|       |        // Eat the opening square bracket
 1401|  8.28k|        fReaderMgr.getNextChar();
 1402|       |
 1403|  8.28k|        checkInternalDTD(hasExtSubset, sysId, pubId);
 1404|       |
 1405|       |        //  And try to scan the internal subset. If we fail, try to recover
 1406|       |        //  by skipping forward tot he close angle and returning.
 1407|  8.28k|        if (!dtdScanner.scanInternalSubset())
  ------------------
  |  Branch (1407:13): [True: 3.60k, False: 4.67k]
  ------------------
 1408|  3.60k|        {
 1409|  3.60k|            fReaderMgr.skipPastChar(chCloseAngle);
 1410|  3.60k|            return;
 1411|  3.60k|        }
 1412|       |
 1413|       |        //  Do a sanity check that some expanded PE did not propogate out of
 1414|       |        //  the doctype. This could happen if it was terminated early by bad
 1415|       |        //  syntax.
 1416|  4.67k|        if (fReaderMgr.getReaderDepth() > 1)
  ------------------
  |  Branch (1416:13): [True: 1, False: 4.67k]
  ------------------
 1417|      1|        {
 1418|      1|            emitError(XMLErrs::PEPropogated);
 1419|       |
 1420|       |            // Ask the reader manager to pop back down to the main level
 1421|      1|            fReaderMgr.cleanStackBackTo(1);
 1422|      1|        }
 1423|       |
 1424|  4.67k|        fReaderMgr.skipPastSpaces();
 1425|  4.67k|    }
 1426|       |
 1427|       |    // And that should leave us at the closing > of the DOCTYPE line
 1428|  4.70k|    if (!fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (1428:9): [True: 6, False: 4.69k]
  ------------------
 1429|      6|    {
 1430|       |        //  Do a special check for the common scenario of an extra ] char at
 1431|       |        //  the end. This is easy to recover from.
 1432|      6|        if (fReaderMgr.skippedChar(chCloseSquare)
  ------------------
  |  Branch (1432:13): [True: 2, False: 4]
  ------------------
 1433|      6|        &&  fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (1433:13): [True: 1, False: 1]
  ------------------
 1434|      1|        {
 1435|      1|            emitError(XMLErrs::ExtraCloseSquare);
 1436|      1|        }
 1437|      5|         else
 1438|      5|        {
 1439|      5|            emitError(XMLErrs::UnterminatedDOCTYPE);
 1440|      5|            fReaderMgr.skipPastChar(chCloseAngle);
 1441|      5|        }
 1442|      6|    }
 1443|       |
 1444|       |    //  If we had an external subset, then we need to deal with that one
 1445|       |    //  next. If we are reusing the validator, then don't scan it.
 1446|  4.70k|    if (hasExtSubset) {
  ------------------
  |  Branch (1446:9): [True: 2.00k, False: 2.69k]
  ------------------
 1447|       |
 1448|  2.00k|        InputSource* srcUsed=0;
 1449|  2.00k|        Janitor<InputSource> janSrc(srcUsed);
 1450|       |        // If we had an internal subset and we're using the cached grammar, it
 1451|       |        // means that the ignoreCachedDTD is set, so we ignore the cached
 1452|       |        // grammar
 1453|  2.00k|        if (fUseCachedGrammar && !hasIntSubset)
  ------------------
  |  Branch (1453:13): [True: 0, False: 2.00k]
  |  Branch (1453:34): [True: 0, False: 0]
  ------------------
 1454|      0|        {
 1455|      0|            srcUsed = resolveSystemId(sysId, pubId);
 1456|      0|            if (srcUsed) {
  ------------------
  |  Branch (1456:17): [True: 0, False: 0]
  ------------------
 1457|      0|                janSrc.reset(srcUsed);
 1458|      0|                Grammar* grammar = fGrammarResolver->getGrammar(srcUsed->getSystemId());
 1459|       |
 1460|      0|                if (grammar && grammar->getGrammarType() == Grammar::DTDGrammarType) {
  ------------------
  |  Branch (1460:21): [True: 0, False: 0]
  |  Branch (1460:32): [True: 0, False: 0]
  ------------------
 1461|       |
 1462|      0|                    fDTDGrammar = (DTDGrammar*) grammar;
 1463|      0|                    fGrammar = fDTDGrammar;
 1464|      0|                    fValidator->setGrammar(fGrammar);
 1465|       |                    // If we don't report at least the external subset boundaries,
 1466|       |                    // an advanced document handler cannot know when the DTD end,
 1467|       |                    // since we've already sent a doctype decl that indicates there's
 1468|       |                    // there's an external subset.
 1469|      0|                    if (fDocTypeHandler)
  ------------------
  |  Branch (1469:25): [True: 0, False: 0]
  ------------------
 1470|      0|                    {
 1471|      0|                        fDocTypeHandler->startExtSubset();
 1472|      0|                        fDocTypeHandler->endExtSubset();
 1473|      0|                    }
 1474|       |
 1475|      0|                    return;
 1476|      0|                }
 1477|      0|            }
 1478|      0|        }
 1479|       |
 1480|  2.00k|        if (fLoadExternalDTD || fValidate)
  ------------------
  |  Branch (1480:13): [True: 2.00k, False: 0]
  |  Branch (1480:33): [True: 0, False: 0]
  ------------------
 1481|  2.00k|        {
 1482|       |            // And now create a reader to read this entity
 1483|  2.00k|            XMLReader* reader;
 1484|  2.00k|            if (srcUsed) {
  ------------------
  |  Branch (1484:17): [True: 0, False: 2.00k]
  ------------------
 1485|      0|                reader = fReaderMgr.createReader
 1486|      0|                        (
 1487|      0|                            *srcUsed
 1488|      0|                            , false
 1489|      0|                            , XMLReader::RefFrom_NonLiteral
 1490|      0|                            , XMLReader::Type_General
 1491|      0|                            , XMLReader::Source_External
 1492|      0|                            , fCalculateSrcOfs
 1493|      0|                            , fLowWaterMark
 1494|      0|                        );
 1495|      0|            }
 1496|  2.00k|            else {
 1497|  2.00k|                reader = fReaderMgr.createReader
 1498|  2.00k|                        (
 1499|  2.00k|                            sysId
 1500|  2.00k|                            , pubId
 1501|  2.00k|                            , false
 1502|  2.00k|                            , XMLReader::RefFrom_NonLiteral
 1503|  2.00k|                            , XMLReader::Type_General
 1504|  2.00k|                            , XMLReader::Source_External
 1505|  2.00k|                            , srcUsed
 1506|  2.00k|                            , fCalculateSrcOfs
 1507|  2.00k|                            , fLowWaterMark
 1508|  2.00k|                            , fDisableDefaultEntityResolution
 1509|  2.00k|                        );
 1510|  2.00k|                janSrc.reset(srcUsed);
 1511|  2.00k|            }
 1512|       |            //  If it failed then throw an exception
 1513|  2.00k|            if (!reader)
  ------------------
  |  Branch (1513:17): [True: 2.00k, False: 0]
  ------------------
 1514|  2.00k|                ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Gen_CouldNotOpenDTD, srcUsed ? srcUsed->getSystemId() : sysId, fMemoryManager);
  ------------------
  |  |  266|  4.00k|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |  |  Branch (266:87): [True: 2.00k, False: 0]
  |  |  ------------------
  ------------------
 1515|       |
 1516|      0|            if (fToCacheGrammar) {
  ------------------
  |  Branch (1516:17): [True: 0, False: 0]
  ------------------
 1517|       |
 1518|      0|                unsigned int stringId = fGrammarResolver->getStringPool()->addOrFind(srcUsed->getSystemId());
 1519|      0|                const XMLCh* sysIdStr = fGrammarResolver->getStringPool()->getValueForId(stringId);
 1520|       |
 1521|      0|                fGrammarResolver->orphanGrammar(XMLUni::fgDTDEntityString);
 1522|      0|                ((XMLDTDDescription*) (fGrammar->getGrammarDescription()))->setSystemId(sysIdStr);
 1523|      0|                fGrammarResolver->putGrammar(fGrammar);
 1524|      0|            }
 1525|       |
 1526|       |            //  In order to make the processing work consistently, we have to
 1527|       |            //  make this look like an external entity. So create an entity
 1528|       |            //  decl and fill it in and push it with the reader, as happens
 1529|       |            //  with an external entity. Put a janitor on it to insure it gets
 1530|       |            //  cleaned up. The reader manager does not adopt them.
 1531|      0|            const XMLCh gDTDStr[] = { chLatin_D, chLatin_T, chLatin_D , chNull };
 1532|      0|            DTDEntityDecl* declDTD = new (fMemoryManager) DTDEntityDecl(gDTDStr, false, fMemoryManager);
 1533|      0|            declDTD->setSystemId(sysId);
 1534|      0|            declDTD->setIsExternal(true);
 1535|      0|            Janitor<DTDEntityDecl> janDecl(declDTD);
 1536|       |
 1537|       |            // Mark this one as a throw at end
 1538|      0|            reader->setThrowAtEnd(true);
 1539|       |
 1540|       |            // And push it onto the stack, with its pseudo name
 1541|      0|            fReaderMgr.pushReader(reader, declDTD);
 1542|       |
 1543|       |            // Tell it its not in an include section
 1544|      0|            dtdScanner.scanExtSubsetDecl(false, true);
 1545|      0|        }
 1546|  2.00k|    }
 1547|  4.70k|}
_ZN11xercesc_3_212IGXMLScanner12scanStartTagERb:
 1550|   558k|{
 1551|       |    //  Assume we will still have data until proven otherwise. It will only
 1552|       |    //  ever be false if this is the root and its empty.
 1553|   558k|    gotData = true;
 1554|       |
 1555|       |    //  Get the QName. In this case, we are not doing namespaces, so we just
 1556|       |    //  use it as is and don't have to break it into parts.
 1557|   558k|    if (!fReaderMgr.getName(fQNameBuf))
  ------------------
  |  Branch (1557:9): [True: 70, False: 558k]
  ------------------
 1558|     70|    {
 1559|     70|        emitError(XMLErrs::ExpectedElementName);
 1560|     70|        fReaderMgr.skipToChar(chOpenAngle);
 1561|     70|        return false;
 1562|     70|    }
 1563|       |
 1564|       |    // Assume it won't be an empty tag
 1565|   558k|    bool isEmpty = false;
 1566|       |
 1567|       |    //  Lets try to look up the element in the validator's element decl pool
 1568|       |    //  We can pass bogus values for the URI id and the base name. We know that
 1569|       |    //  this can only be called if we are doing a DTD style validator and that
 1570|       |    //  he will only look at the QName.
 1571|       |    //
 1572|       |    //  We tell him to fault in a decl if he does not find one.
 1573|       |    //  Actually, we *don't* tell him to fault in a decl if he does not find one- NG
 1574|   558k|    bool wasAdded = false;
 1575|   558k|    const XMLCh *rawQName = fQNameBuf.getRawBuffer();
 1576|   558k|    XMLElementDecl* elemDecl = fGrammar->getElemDecl
 1577|   558k|    (
 1578|   558k|        fEmptyNamespaceId
 1579|   558k|        , 0
 1580|   558k|        , rawQName
 1581|   558k|        , Grammar::TOP_LEVEL_SCOPE
 1582|   558k|    );
 1583|       |    // look for it in the undeclared pool:
 1584|   558k|    if(!elemDecl)
  ------------------
  |  Branch (1584:8): [True: 439k, False: 119k]
  ------------------
 1585|   439k|    {
 1586|   439k|        elemDecl = fDTDElemNonDeclPool->getByKey(rawQName);
 1587|   439k|    }
 1588|   558k|    if(!elemDecl)
  ------------------
  |  Branch (1588:8): [True: 5.66k, False: 552k]
  ------------------
 1589|  5.66k|    {
 1590|       |        // we're assuming this must be a DTD element.  DTD's can be
 1591|       |        // used with or without namespaces, but schemas cannot be used without
 1592|       |        // namespaces.
 1593|  5.66k|        wasAdded = true;
 1594|  5.66k|        elemDecl = new (fMemoryManager) DTDElementDecl
 1595|  5.66k|        (
 1596|  5.66k|            rawQName
 1597|  5.66k|            , fEmptyNamespaceId
 1598|  5.66k|            , DTDElementDecl::Any
 1599|  5.66k|            , fMemoryManager
 1600|  5.66k|        );
 1601|  5.66k|        elemDecl->setId(fDTDElemNonDeclPool->put((DTDElementDecl*)elemDecl));
 1602|  5.66k|    }
 1603|       |
 1604|       |    //  We do something different here according to whether we found the
 1605|       |    //  element or not.
 1606|   558k|    if (wasAdded)
  ------------------
  |  Branch (1606:9): [True: 5.66k, False: 552k]
  ------------------
 1607|  5.66k|    {
 1608|       |        // If validating then emit an error
 1609|  5.66k|        if (fValidate)
  ------------------
  |  Branch (1609:13): [True: 5.66k, False: 0]
  ------------------
 1610|  5.66k|        {
 1611|       |            // This is to tell the reuse Validator that this element was
 1612|       |            // faulted-in, was not an element in the validator pool originally
 1613|  5.66k|            elemDecl->setCreateReason(XMLElementDecl::JustFaultIn);
 1614|       |
 1615|  5.66k|            fValidator->emitError
 1616|  5.66k|            (
 1617|  5.66k|                XMLValid::ElementNotDefined
 1618|  5.66k|                , elemDecl->getFullName()
 1619|  5.66k|            );
 1620|  5.66k|        }
 1621|  5.66k|    }
 1622|   552k|    else
 1623|   552k|    {
 1624|       |        // If its not marked declared and validating, then emit an error
 1625|   552k|        if (fValidate && !elemDecl->isDeclared())
  ------------------
  |  Branch (1625:13): [True: 552k, False: 3]
  |  Branch (1625:26): [True: 525k, False: 26.8k]
  ------------------
 1626|   525k|        {
 1627|   525k|            fValidator->emitError
 1628|   525k|            (
 1629|   525k|                XMLValid::ElementNotDefined
 1630|   525k|                , elemDecl->getFullName()
 1631|   525k|            );
 1632|   525k|        }
 1633|   552k|    }
 1634|       |
 1635|       |    // See if its the root element
 1636|   558k|    const bool isRoot = fElemStack.isEmpty();
 1637|       |
 1638|       |    // Expand the element stack and add the new element
 1639|   558k|    fElemStack.addLevel(elemDecl, fReaderMgr.getCurrentReaderNum());
 1640|   558k|    fElemStack.setValidationFlag(fValidate);
 1641|       |
 1642|       |    //  Validate the element
 1643|   558k|    if (fValidate)
  ------------------
  |  Branch (1643:9): [True: 558k, False: 3]
  ------------------
 1644|   558k|        fValidator->validateElement(elemDecl);
 1645|       |
 1646|       |    //  If this is the first element and we are validating, check the root
 1647|       |    //  element.
 1648|   558k|    if (isRoot)
  ------------------
  |  Branch (1648:9): [True: 3.87k, False: 554k]
  ------------------
 1649|  3.87k|    {
 1650|  3.87k|        fRootGrammar = fGrammar;
 1651|       |
 1652|  3.87k|        if (fValidate)
  ------------------
  |  Branch (1652:13): [True: 3.87k, False: 0]
  ------------------
 1653|  3.87k|        {
 1654|       |            //  If a DocType exists, then check if it matches the root name there.
 1655|  3.87k|            if (fRootElemName && !XMLString::equals(fQNameBuf.getRawBuffer(), fRootElemName))
  ------------------
  |  Branch (1655:17): [True: 3.87k, False: 0]
  |  Branch (1655:34): [True: 3.53k, False: 340]
  ------------------
 1656|  3.53k|                fValidator->emitError(XMLValid::RootElemNotLikeDocType);
 1657|  3.87k|        }
 1658|  3.87k|    }
 1659|   554k|    else
 1660|   554k|    {
 1661|       |        //  If the element stack is not empty, then add this element as a
 1662|       |        //  child of the previous top element. If its empty, this is the root
 1663|       |        //  elem and is not the child of anything.
 1664|   554k|        fElemStack.addChild(elemDecl->getElementName(), true);
 1665|   554k|    }
 1666|       |
 1667|       |    // Skip any whitespace after the name
 1668|   558k|    fReaderMgr.skipPastSpaces();
 1669|       |
 1670|       |    //  We loop until we either see a /> or >, handling attribute/value
 1671|       |    //  pairs until we get there.
 1672|   558k|    XMLSize_t    attCount = 0;
 1673|   558k|    XMLSize_t    curAttListSize = fAttrList->size();
 1674|   558k|    wasAdded = false;
 1675|       |
 1676|   558k|    fElemCount++;
 1677|       |
 1678|  1.03M|    while (true)
  ------------------
  |  Branch (1678:12): [Folded - Ignored]
  ------------------
 1679|  1.03M|    {
 1680|       |        // And get the next non-space character
 1681|  1.03M|        XMLCh nextCh = fReaderMgr.peekNextChar();
 1682|       |
 1683|       |        //  If the next character is not a slash or closed angle bracket,
 1684|       |        //  then it must be whitespace, since whitespace is required
 1685|       |        //  between the end of the last attribute and the name of the next
 1686|       |        //  one.
 1687|  1.03M|        if (attCount)
  ------------------
  |  Branch (1687:13): [True: 473k, False: 558k]
  ------------------
 1688|   473k|        {
 1689|   473k|            if ((nextCh != chForwardSlash) && (nextCh != chCloseAngle))
  ------------------
  |  Branch (1689:17): [True: 366k, False: 106k]
  |  Branch (1689:47): [True: 365k, False: 1.41k]
  ------------------
 1690|   365k|            {
 1691|   365k|                bool bFoundSpace;
 1692|   365k|                fReaderMgr.skipPastSpaces(bFoundSpace);
 1693|   365k|                if (!bFoundSpace)
  ------------------
  |  Branch (1693:21): [True: 16, False: 365k]
  ------------------
 1694|     16|                {
 1695|       |                    // Emit the error but keep on going
 1696|     16|                    emitError(XMLErrs::ExpectedWhitespace);
 1697|     16|                }
 1698|       |                // Ok, peek another char
 1699|   365k|                nextCh = fReaderMgr.peekNextChar();
 1700|   365k|            }
 1701|   473k|        }
 1702|       |
 1703|       |        //  Ok, here we first check for any of the special case characters.
 1704|       |        //  If its not one, then we do the normal case processing, which
 1705|       |        //  assumes that we've hit an attribute value, Otherwise, we do all
 1706|       |        //  the special case checks.
 1707|  1.03M|        if (!fReaderMgr.getCurrentReader()->isSpecialStartTagChar(nextCh))
  ------------------
  |  Branch (1707:13): [True: 473k, False: 558k]
  ------------------
 1708|   473k|        {
 1709|       |            //  Assume its going to be an attribute, so get a name from
 1710|       |            //  the input.
 1711|   473k|            if (!fReaderMgr.getName(fAttNameBuf))
  ------------------
  |  Branch (1711:17): [True: 32, False: 473k]
  ------------------
 1712|     32|            {
 1713|     32|                emitError(XMLErrs::ExpectedAttrName);
 1714|     32|                fReaderMgr.skipPastChar(chCloseAngle);
 1715|     32|                return false;
 1716|     32|            }
 1717|       |
 1718|       |            // And next must be an equal sign
 1719|   473k|            if (!scanEq())
  ------------------
  |  Branch (1719:17): [True: 44, False: 473k]
  ------------------
 1720|     44|            {
 1721|     44|                static const XMLCh tmpList[] =
 1722|     44|                {
 1723|     44|                    chSingleQuote, chDoubleQuote, chCloseAngle
 1724|     44|                    , chOpenAngle, chForwardSlash, chNull
 1725|     44|                };
 1726|       |
 1727|     44|                emitError(XMLErrs::ExpectedEqSign);
 1728|       |
 1729|       |                //  Try to sync back up by skipping forward until we either
 1730|       |                //  hit something meaningful.
 1731|     44|                const XMLCh chFound = fReaderMgr.skipUntilInOrWS(tmpList);
 1732|       |
 1733|     44|                if ((chFound == chCloseAngle) || (chFound == chForwardSlash))
  ------------------
  |  Branch (1733:21): [True: 44, False: 0]
  |  Branch (1733:50): [True: 0, False: 0]
  ------------------
 1734|      0|                {
 1735|       |                    // Jump back to top for normal processing of these
 1736|      0|                    continue;
 1737|      0|                }
 1738|     44|                else if ((chFound == chSingleQuote)
  ------------------
  |  Branch (1738:26): [True: 44, False: 0]
  ------------------
 1739|     44|                      ||  (chFound == chDoubleQuote)
  ------------------
  |  Branch (1739:27): [True: 0, False: 0]
  ------------------
 1740|     44|                      ||  fReaderMgr.getCurrentReader()->isWhitespace(chFound))
  ------------------
  |  Branch (1740:27): [True: 0, False: 0]
  ------------------
 1741|      0|                {
 1742|       |                    // Just fall through assuming that the value is to follow
 1743|      0|                }
 1744|     44|                else if (chFound == chOpenAngle)
  ------------------
  |  Branch (1744:26): [True: 0, False: 44]
  ------------------
 1745|      0|                {
 1746|       |                    // Assume a malformed tag and that new one is starting
 1747|      0|                    emitError(XMLErrs::UnterminatedStartTag, elemDecl->getFullName());
 1748|      0|                    return false;
 1749|      0|                }
 1750|     44|                else
 1751|     44|                {
 1752|       |                    // Something went really wrong
 1753|     44|                    return false;
 1754|     44|                }
 1755|     44|            }
 1756|       |            //  See if this attribute is declared for this element. If we are
 1757|       |            //  not validating of course it will not be at first, but we will
 1758|       |            //  fault it into the pool (to avoid lots of redundant errors.)
 1759|   473k|            XMLCh * namePtr = fAttNameBuf.getRawBuffer();
 1760|   473k|            XMLAttDef* attDef = ((DTDElementDecl *)elemDecl)->getAttDef(namePtr);
 1761|       |
 1762|       |            //  Add this attribute to the attribute list that we use to
 1763|       |            //  pass them to the handler. We reuse its existing elements
 1764|       |            //  but expand it as required.
 1765|       |            // Note that we want to this first since this will
 1766|       |            // make a copy of the namePtr; we can then make use of
 1767|       |            // that copy in the hashtable lookup that checks
 1768|       |            // for duplicates.  This will mean we may have to update
 1769|       |            // the type of the XMLAttr later.
 1770|   473k|            XMLAttr* curAtt;
 1771|   473k|            if (attCount >= curAttListSize)
  ------------------
  |  Branch (1771:17): [True: 2.72k, False: 470k]
  ------------------
 1772|  2.72k|            {
 1773|  2.72k|                curAtt = new (fMemoryManager) XMLAttr
 1774|  2.72k|                (
 1775|  2.72k|                    0
 1776|  2.72k|                    , namePtr
 1777|  2.72k|                    , XMLUni::fgZeroLenString
 1778|  2.72k|                    , XMLUni::fgZeroLenString
 1779|  2.72k|                    , (attDef)?attDef->getType():XMLAttDef::CData
  ------------------
  |  Branch (1779:23): [True: 447, False: 2.27k]
  ------------------
 1780|  2.72k|                    , true
 1781|  2.72k|                    , fMemoryManager
 1782|  2.72k|                );
 1783|  2.72k|                fAttrList->addElement(curAtt);
 1784|  2.72k|            }
 1785|   470k|            else
 1786|   470k|            {
 1787|   470k|                curAtt = fAttrList->elementAt(attCount);
 1788|   470k|                curAtt->set
 1789|   470k|                (
 1790|   470k|                    0
 1791|   470k|                    , namePtr
 1792|   470k|                    , XMLUni::fgZeroLenString
 1793|   470k|                    , XMLUni::fgZeroLenString
 1794|   470k|                    , (attDef)?attDef->getType():XMLAttDef::CData
  ------------------
  |  Branch (1794:23): [True: 8.97k, False: 461k]
  ------------------
 1795|   470k|                );
 1796|   470k|                curAtt->setSpecified(true);
 1797|   470k|            }
 1798|       |            // reset namePtr so it refers to newly-allocated memory
 1799|   473k|            namePtr = (XMLCh *)curAtt->getName();
 1800|       |
 1801|   473k|            if (!attDef)
  ------------------
  |  Branch (1801:17): [True: 464k, False: 9.42k]
  ------------------
 1802|   464k|            {
 1803|       |                //  If there is a validation handler, then we are validating
 1804|       |                //  so emit an error.
 1805|   464k|                if (fValidate)
  ------------------
  |  Branch (1805:21): [True: 464k, False: 0]
  ------------------
 1806|   464k|                {
 1807|   464k|                    fValidator->emitError
 1808|   464k|                    (
 1809|   464k|                        XMLValid::AttNotDefinedForElement
 1810|   464k|                        , fAttNameBuf.getRawBuffer()
 1811|   464k|                        , elemDecl->getFullName()
 1812|   464k|                    );
 1813|   464k|                }
 1814|   464k|                if(!fUndeclaredAttrRegistry->putIfNotPresent(namePtr, 0))
  ------------------
  |  Branch (1814:20): [True: 28, False: 464k]
  ------------------
 1815|     28|                {
 1816|     28|                    emitError
 1817|     28|                    (
 1818|     28|                        XMLErrs::AttrAlreadyUsedInSTag
 1819|     28|                        , namePtr
 1820|     28|                        , elemDecl->getFullName()
 1821|     28|                     );
 1822|     28|                }
 1823|   464k|            }
 1824|  9.42k|            else
 1825|  9.42k|            {
 1826|       |                // prepare for duplicate detection
 1827|  9.42k|                unsigned int *curCountPtr = fAttDefRegistry->get(attDef);
 1828|  9.42k|                if(!curCountPtr)
  ------------------
  |  Branch (1828:20): [True: 705, False: 8.71k]
  ------------------
 1829|    705|                {
 1830|    705|                    curCountPtr = getNewUIntPtr();
 1831|    705|                    *curCountPtr = fElemCount;
 1832|    705|                    fAttDefRegistry->put(attDef, curCountPtr);
 1833|    705|                }
 1834|  8.71k|                else if(*curCountPtr < fElemCount)
  ------------------
  |  Branch (1834:25): [True: 8.70k, False: 9]
  ------------------
 1835|  8.70k|                    *curCountPtr = fElemCount;
 1836|      9|                else
 1837|      9|                {
 1838|      9|                    emitError
 1839|      9|                    (
 1840|      9|                        XMLErrs::AttrAlreadyUsedInSTag
 1841|      9|                        , attDef->getFullName()
 1842|      9|                        , elemDecl->getFullName()
 1843|      9|                    );
 1844|      9|                }
 1845|  9.42k|            }
 1846|       |
 1847|       |            //  Skip any whitespace before the value and then scan the att
 1848|       |            //  value. This will come back normalized with entity refs and
 1849|       |            //  char refs expanded.
 1850|   473k|            fReaderMgr.skipPastSpaces();
 1851|   473k|            if (!scanAttValue(attDef, namePtr, fAttValueBuf))
  ------------------
  |  Branch (1851:17): [True: 23, False: 473k]
  ------------------
 1852|     23|            {
 1853|     23|                static const XMLCh tmpList[] =
 1854|     23|                {
 1855|     23|                    chCloseAngle, chOpenAngle, chForwardSlash, chNull
 1856|     23|                };
 1857|       |
 1858|     23|                emitError(XMLErrs::ExpectedAttrValue);
 1859|       |
 1860|       |                //  It failed, so lets try to get synced back up. We skip
 1861|       |                //  forward until we find some whitespace or one of the
 1862|       |                //  chars in our list.
 1863|     23|                const XMLCh chFound = fReaderMgr.skipUntilInOrWS(tmpList);
 1864|       |
 1865|     23|                if ((chFound == chCloseAngle)
  ------------------
  |  Branch (1865:21): [True: 23, False: 0]
  ------------------
 1866|     23|                ||  (chFound == chForwardSlash)
  ------------------
  |  Branch (1866:21): [True: 0, False: 0]
  ------------------
 1867|     23|                ||  fReaderMgr.getCurrentReader()->isWhitespace(chFound))
  ------------------
  |  Branch (1867:21): [True: 0, False: 0]
  ------------------
 1868|      0|                {
 1869|       |                    //  Just fall through and process this attribute, though
 1870|       |                    //  the value will be "".
 1871|      0|                }
 1872|     23|                else if (chFound == chOpenAngle)
  ------------------
  |  Branch (1872:26): [True: 0, False: 23]
  ------------------
 1873|      0|                {
 1874|       |                    // Assume a malformed tag and that new one is starting
 1875|      0|                    emitError(XMLErrs::UnterminatedStartTag, elemDecl->getFullName());
 1876|      0|                    return false;
 1877|      0|                }
 1878|     23|                else
 1879|     23|                {
 1880|       |                    // Something went really wrong
 1881|     23|                    return false;
 1882|     23|                }
 1883|     23|            }
 1884|       |            // must set the newly-minted value on the XMLAttr:
 1885|   473k|            curAtt->setValue(fAttValueBuf.getRawBuffer());
 1886|       |
 1887|       |            //  Now that its all stretched out, lets look at its type and
 1888|       |            //  determine if it has a valid value. It will output any needed
 1889|       |            //  errors, but we just keep going. We only need to do this if
 1890|       |            //  we are validating.
 1891|   473k|            if (attDef)
  ------------------
  |  Branch (1891:17): [True: 9.37k, False: 464k]
  ------------------
 1892|  9.37k|            {
 1893|       |                // Let the validator pass judgement on the attribute value
 1894|  9.37k|                if (fValidate)
  ------------------
  |  Branch (1894:21): [True: 9.37k, False: 0]
  ------------------
 1895|  9.37k|                {
 1896|  9.37k|                    fValidator->validateAttrValue
 1897|  9.37k|                    (
 1898|  9.37k|                        attDef
 1899|  9.37k|                        , fAttValueBuf.getRawBuffer()
 1900|  9.37k|                        , false
 1901|  9.37k|                        , elemDecl
 1902|  9.37k|                    );
 1903|  9.37k|                }
 1904|  9.37k|            }
 1905|       |
 1906|   473k|            attCount++;
 1907|       |            // And jump back to the top of the loop
 1908|   473k|            continue;
 1909|   473k|        }
 1910|       |
 1911|       |        //  It was some special case character so do all of the checks and
 1912|       |        //  deal with it.
 1913|   558k|        if (!nextCh)
  ------------------
  |  Branch (1913:13): [True: 3, False: 558k]
  ------------------
 1914|      3|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      3|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1915|       |
 1916|   558k|        if (nextCh == chForwardSlash)
  ------------------
  |  Branch (1916:13): [True: 133k, False: 424k]
  ------------------
 1917|   133k|        {
 1918|   133k|            fReaderMgr.getNextChar();
 1919|   133k|            isEmpty = true;
 1920|   133k|            if (!fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (1920:17): [True: 10, False: 133k]
  ------------------
 1921|     10|                emitError(XMLErrs::UnterminatedStartTag, elemDecl->getFullName());
 1922|   133k|            break;
 1923|   133k|        }
 1924|   424k|        else if (nextCh == chCloseAngle)
  ------------------
  |  Branch (1924:18): [True: 424k, False: 33]
  ------------------
 1925|   424k|        {
 1926|   424k|            fReaderMgr.getNextChar();
 1927|   424k|            break;
 1928|   424k|        }
 1929|     33|        else if (nextCh == chOpenAngle)
  ------------------
  |  Branch (1929:18): [True: 12, False: 21]
  ------------------
 1930|     12|        {
 1931|       |            //  Check for this one specially, since its going to be common
 1932|       |            //  and it is kind of auto-recovering since we've already hit the
 1933|       |            //  next open bracket, which is what we would have seeked to (and
 1934|       |            //  skipped this whole tag.)
 1935|     12|            emitError(XMLErrs::UnterminatedStartTag, elemDecl->getFullName());
 1936|     12|            break;
 1937|     12|        }
 1938|     21|        else if ((nextCh == chSingleQuote) || (nextCh == chDoubleQuote))
  ------------------
  |  Branch (1938:18): [True: 18, False: 3]
  |  Branch (1938:47): [True: 3, False: 0]
  ------------------
 1939|      5|        {
 1940|       |            //  Check for this one specially, which is probably a missing
 1941|       |            //  attribute name, e.g. ="value". Just issue expected name
 1942|       |            //  error and eat the quoted string, then jump back to the
 1943|       |            //  top again.
 1944|      5|            emitError(XMLErrs::ExpectedAttrName);
 1945|      5|            fReaderMgr.getNextChar();
 1946|      5|            fReaderMgr.skipQuotedString(nextCh);
 1947|      5|            fReaderMgr.skipPastSpaces();
 1948|      5|            continue;
 1949|      5|        }
 1950|   558k|    }
 1951|       |
 1952|   558k|    if(attCount)
  ------------------
  |  Branch (1952:8): [True: 463k, False: 94.8k]
  ------------------
 1953|   463k|    {
 1954|       |        // clean up after ourselves:
 1955|       |        // clear the map used to detect duplicate attributes
 1956|   463k|        fUndeclaredAttrRegistry->removeAll();
 1957|   463k|    }
 1958|       |
 1959|       |    //  Ok, so lets get an enumerator for the attributes of this element
 1960|       |    //  and run through them for well formedness and validity checks. But
 1961|       |    //  make sure that we had any attributes before we do it, since the list
 1962|       |    //  would have have gotten faulted in anyway.
 1963|   558k|    if (elemDecl->hasAttDefs())
  ------------------
  |  Branch (1963:9): [True: 21.2k, False: 537k]
  ------------------
 1964|  21.2k|    {
 1965|       |        // N.B.:  this assumes DTD validation.
 1966|  21.2k|        XMLAttDefList& attDefList = elemDecl->getAttDefList();
 1967|   264k|        for(XMLSize_t i=0; i<attDefList.getAttDefCount(); i++)
  ------------------
  |  Branch (1967:28): [True: 243k, False: 21.2k]
  ------------------
 1968|   243k|        {
 1969|       |            // Get the current att def, for convenience and its def type
 1970|   243k|            const XMLAttDef& curDef = attDefList.getAttDef(i);
 1971|   243k|            const XMLAttDef::DefAttTypes defType = curDef.getDefaultType();
 1972|       |
 1973|   243k|            unsigned int *attCountPtr = fAttDefRegistry->get(&curDef);
 1974|   243k|            if (!attCountPtr || *attCountPtr < fElemCount)
  ------------------
  |  Branch (1974:17): [True: 122k, False: 120k]
  |  Branch (1974:33): [True: 111k, False: 9.33k]
  ------------------
 1975|   234k|            { // did not occur
 1976|   234k|                if (fValidate)
  ------------------
  |  Branch (1976:21): [True: 234k, False: 0]
  ------------------
 1977|   234k|                {
 1978|       |                    // If we are validating and its required, then an error
 1979|   234k|                    if (defType == XMLAttDef::Required)
  ------------------
  |  Branch (1979:25): [True: 182k, False: 52.0k]
  ------------------
 1980|   182k|                    {
 1981|   182k|                        fValidator->emitError
 1982|   182k|                        (
 1983|   182k|                            XMLValid::RequiredAttrNotProvided
 1984|   182k|                            , curDef.getFullName()
 1985|   182k|                        );
 1986|   182k|                    }
 1987|  52.0k|                    else if ((defType == XMLAttDef::Default) ||
  ------------------
  |  Branch (1987:30): [True: 0, False: 52.0k]
  ------------------
 1988|  52.0k|		                       (defType == XMLAttDef::Fixed)  )
  ------------------
  |  Branch (1988:26): [True: 44.0k, False: 8.00k]
  ------------------
 1989|  44.0k|                    {
 1990|  44.0k|                        if (fStandalone && curDef.isExternal())
  ------------------
  |  Branch (1990:29): [True: 43.8k, False: 221]
  |  Branch (1990:44): [True: 0, False: 43.8k]
  ------------------
 1991|      0|                        {
 1992|       |                            // XML 1.0 Section 2.9
 1993|       |                            // Document is standalone, so attributes must not be defaulted.
 1994|      0|                            fValidator->emitError(XMLValid::NoDefAttForStandalone, curDef.getFullName(), elemDecl->getFullName());
 1995|       |
 1996|      0|                        }
 1997|  44.0k|                    }
 1998|   234k|                }
 1999|       |
 2000|       |                // Fault in the value if needed, and bump the att count
 2001|   234k|                if ((defType == XMLAttDef::Default)
  ------------------
  |  Branch (2001:21): [True: 0, False: 234k]
  ------------------
 2002|   234k|                ||  (defType == XMLAttDef::Fixed))
  ------------------
  |  Branch (2002:21): [True: 44.0k, False: 190k]
  ------------------
 2003|  44.0k|                {
 2004|       |                    // Let the validator pass judgement on the attribute value
 2005|  44.0k|                    if (fValidate)
  ------------------
  |  Branch (2005:25): [True: 44.0k, False: 0]
  ------------------
 2006|  44.0k|                    {
 2007|  44.0k|                        fValidator->validateAttrValue
 2008|  44.0k|                        (
 2009|  44.0k|                            &curDef
 2010|  44.0k|                            , curDef.getValue()
 2011|  44.0k|                            , false
 2012|  44.0k|                            , elemDecl
 2013|  44.0k|                        );
 2014|  44.0k|                    }
 2015|       |
 2016|  44.0k|                    XMLAttr* curAtt;
 2017|  44.0k|                    if (attCount >= curAttListSize)
  ------------------
  |  Branch (2017:25): [True: 394, False: 43.6k]
  ------------------
 2018|    394|                    {
 2019|    394|                        curAtt = new (fMemoryManager) XMLAttr
 2020|    394|                        (
 2021|    394|                            0
 2022|    394|                            , curDef.getFullName()
 2023|    394|                            , XMLUni::fgZeroLenString
 2024|    394|                            , curDef.getValue()
 2025|    394|                            , curDef.getType()
 2026|    394|                            , false
 2027|    394|                            , fMemoryManager
 2028|    394|                        );
 2029|    394|                        fAttrList->addElement(curAtt);
 2030|    394|                        curAttListSize++;
 2031|    394|                    }
 2032|  43.6k|                    else
 2033|  43.6k|                    {
 2034|  43.6k|                        curAtt = fAttrList->elementAt(attCount);
 2035|  43.6k|                        curAtt->set
 2036|  43.6k|                        (
 2037|  43.6k|                            0
 2038|  43.6k|                            , curDef.getFullName()
 2039|  43.6k|                            , XMLUni::fgZeroLenString
 2040|  43.6k|                            , curDef.getValue()
 2041|  43.6k|                            , curDef.getType()
 2042|  43.6k|                        );
 2043|  43.6k|                        curAtt->setSpecified(false);
 2044|  43.6k|                    }
 2045|  44.0k|                    attCount++;
 2046|  44.0k|                }
 2047|   234k|            }
 2048|   243k|        }
 2049|  21.2k|    }
 2050|       |
 2051|       |    //  If empty, validate content right now if we are validating and then
 2052|       |    //  pop the element stack top. Else, we have to update the current stack
 2053|       |    //  top's namespace mapping elements.
 2054|   558k|    if (isEmpty)
  ------------------
  |  Branch (2054:9): [True: 133k, False: 424k]
  ------------------
 2055|   133k|    {
 2056|       |        // If validating, then insure that its legal to have no content
 2057|   133k|        if (fValidate)
  ------------------
  |  Branch (2057:13): [True: 133k, False: 0]
  ------------------
 2058|   133k|        {
 2059|   133k|            XMLSize_t failure;
 2060|   133k|            bool res = fValidator->checkContent(elemDecl, 0, 0, &failure);
 2061|   133k|            if (!res)
  ------------------
  |  Branch (2061:17): [True: 6.92k, False: 126k]
  ------------------
 2062|  6.92k|            {
 2063|  6.92k|                fValidator->emitError
 2064|  6.92k|                (
 2065|  6.92k|                    XMLValid::ElementNotValidForContent
 2066|  6.92k|                    , elemDecl->getFullName()
 2067|  6.92k|                    , elemDecl->getFormattedContentModel()
 2068|  6.92k|                );
 2069|  6.92k|            }
 2070|   133k|        }
 2071|       |
 2072|       |        // Pop the element stack back off since it'll never be used now
 2073|   133k|        fElemStack.popTop();
 2074|       |
 2075|       |        // If the elem stack is empty, then it was an empty root
 2076|   133k|        if (isRoot)
  ------------------
  |  Branch (2076:13): [True: 980, False: 132k]
  ------------------
 2077|    980|            gotData = false;
 2078|   132k|        else {
 2079|       |            // Restore the validation flag
 2080|   132k|            fValidate = fElemStack.getValidationFlag();
 2081|   132k|        }
 2082|   133k|    }
 2083|       |
 2084|       |    //  If we have a document handler, then tell it about this start tag. We
 2085|       |    //  don't have any URI id to send along, so send fEmptyNamespaceId. We also do not send
 2086|       |    //  any prefix since its just one big name if we are not doing namespaces.
 2087|   558k|    if (fDocHandler)
  ------------------
  |  Branch (2087:9): [True: 0, False: 558k]
  ------------------
 2088|      0|    {
 2089|      0|        fDocHandler->startElement
 2090|      0|        (
 2091|      0|            *elemDecl
 2092|      0|            , fEmptyNamespaceId
 2093|      0|            , 0
 2094|      0|            , *fAttrList
 2095|      0|            , attCount
 2096|      0|            , isEmpty
 2097|      0|            , isRoot
 2098|      0|        );
 2099|      0|    }
 2100|       |
 2101|   558k|    return true;
 2102|   558k|}
_ZN11xercesc_3_212IGXMLScanner20resetPSVIElemContextEv:
 3260|  8.51k|{
 3261|  8.51k|    fPSVIElemContext.fIsSpecified = false;
 3262|  8.51k|    fPSVIElemContext.fErrorOccurred = false;
 3263|  8.51k|    fPSVIElemContext.fElemDepth = -1;
 3264|  8.51k|    fPSVIElemContext.fFullValidationDepth = -1;
 3265|  8.51k|    fPSVIElemContext.fNoneValidationDepth = -1;
 3266|  8.51k|    fPSVIElemContext.fCurrentDV = 0;
 3267|  8.51k|    fPSVIElemContext.fCurrentTypeInfo = 0;
 3268|  8.51k|    fPSVIElemContext.fNormalizedValue = 0;
 3269|  8.51k|}

_ZN11xercesc_3_212IGXMLScanner9scanResetERKNS_11InputSourceE:
 1160|  8.51k|{
 1161|       |    //  This call implicitly tells us that we are going to reuse the scanner
 1162|       |    //  if it was previously used. So tell the validator to reset itself.
 1163|       |    //
 1164|       |    //  But, if the fUseCacheGrammar flag is set, then don't reset it.
 1165|       |    //
 1166|       |    //  NOTE:   The ReaderMgr is flushed on the way out, because that is
 1167|       |    //          required to insure that files are closed.
 1168|  8.51k|    fGrammarResolver->cacheGrammarFromParse(fToCacheGrammar);
 1169|  8.51k|    fGrammarResolver->useCachedGrammarInParse(fUseCachedGrammar);
 1170|       |
 1171|       |    // Clear transient schema info list.
 1172|       |    //
 1173|  8.51k|    fSchemaInfoList->removeAll ();
 1174|       |
 1175|       |    // fModel may need updating, as fGrammarResolver could have cleaned it
 1176|  8.51k|    if(getPSVIHandler())
  ------------------
  |  Branch (1176:8): [True: 0, False: 8.51k]
  ------------------
 1177|      0|        fModel = fGrammarResolver->getXSModel();
 1178|       |
 1179|  8.51k|    {
 1180|  8.51k|        XMLDTDDescriptionImpl   theDTDDescription(XMLUni::fgDTDEntityString, fMemoryManager);
 1181|  8.51k|        fDTDGrammar = (DTDGrammar*) fGrammarResolver->getGrammar(&theDTDDescription);
 1182|  8.51k|    }
 1183|       |
 1184|  8.51k|    if (!fDTDGrammar) {
  ------------------
  |  Branch (1184:9): [True: 8.51k, False: 0]
  ------------------
 1185|       |
 1186|  8.51k|        fDTDGrammar = new (fGrammarPoolMemoryManager) DTDGrammar(fGrammarPoolMemoryManager);
 1187|  8.51k|        fGrammarResolver->putGrammar(fDTDGrammar);
 1188|  8.51k|    }
 1189|      0|    else
 1190|      0|        fDTDGrammar->reset();
 1191|       |
 1192|  8.51k|    fGrammar = fDTDGrammar;
 1193|  8.51k|    fGrammarType = fGrammar->getGrammarType();
 1194|  8.51k|    fRootGrammar = 0;
 1195|       |
 1196|  8.51k|    if (fValidatorFromUser) {
  ------------------
  |  Branch (1196:9): [True: 0, False: 8.51k]
  ------------------
 1197|      0|        if (fValidator->handlesDTD())
  ------------------
  |  Branch (1197:13): [True: 0, False: 0]
  ------------------
 1198|      0|            fValidator->setGrammar(fGrammar);
 1199|      0|        else if (fValidator->handlesSchema()) {
  ------------------
  |  Branch (1199:18): [True: 0, False: 0]
  ------------------
 1200|       |
 1201|      0|            ((SchemaValidator*) fValidator)->setErrorReporter(fErrorReporter);
 1202|      0|            ((SchemaValidator*) fValidator)->setGrammarResolver(fGrammarResolver);
 1203|      0|            ((SchemaValidator*) fValidator)->setExitOnFirstFatal(fExitOnFirstFatal);
 1204|      0|        }
 1205|      0|    }
 1206|  8.51k|    else {
 1207|       |        // set fValidator as fDTDValidator
 1208|  8.51k|        fValidator = fDTDValidator;
 1209|  8.51k|        fValidator->setGrammar(fGrammar);
 1210|  8.51k|    }
 1211|       |
 1212|       |    // Reset validation
 1213|  8.51k|    fValidate = (fValScheme == Val_Always) ? true : false;
  ------------------
  |  Branch (1213:17): [True: 0, False: 8.51k]
  ------------------
 1214|       |
 1215|       |    // Ignore skipDTDValidation flag if no schema processing is taking place */
 1216|  8.51k|    fSkipDTDValidation = fSkipDTDValidation && fDoSchema;
  ------------------
  |  Branch (1216:26): [True: 0, False: 8.51k]
  |  Branch (1216:48): [True: 0, False: 0]
  ------------------
 1217|       |
 1218|       |    //  And for all installed handlers, send reset events. This gives them
 1219|       |    //  a chance to flush any cached data.
 1220|  8.51k|    if (fDocHandler)
  ------------------
  |  Branch (1220:9): [True: 0, False: 8.51k]
  ------------------
 1221|      0|        fDocHandler->resetDocument();
 1222|  8.51k|    if (fEntityHandler)
  ------------------
  |  Branch (1222:9): [True: 0, False: 8.51k]
  ------------------
 1223|      0|        fEntityHandler->resetEntities();
 1224|  8.51k|    if (fErrorReporter)
  ------------------
  |  Branch (1224:9): [True: 0, False: 8.51k]
  ------------------
 1225|      0|        fErrorReporter->resetErrors();
 1226|       |
 1227|       |    // Clear out the id reference list
 1228|  8.51k|    resetValidationContext();
 1229|       |
 1230|       |    // Reset the Root Element Name
 1231|  8.51k|    fMemoryManager->deallocate(fRootElemName);//delete [] fRootElemName;
 1232|  8.51k|    fRootElemName = 0;
 1233|       |
 1234|       |    // Reset IdentityConstraints
 1235|  8.51k|    if (fICHandler)
  ------------------
  |  Branch (1235:9): [True: 8.51k, False: 0]
  ------------------
 1236|  8.51k|        fICHandler->reset();
 1237|       |
 1238|       |    //  Reset the element stack, and give it the latest ids for the special
 1239|       |    //  URIs it has to know about.
 1240|  8.51k|    fElemStack.reset
 1241|  8.51k|    (
 1242|  8.51k|        fEmptyNamespaceId
 1243|  8.51k|        , fUnknownNamespaceId
 1244|  8.51k|        , fXMLNamespaceId
 1245|  8.51k|        , fXMLNSNamespaceId
 1246|  8.51k|    );
 1247|       |
 1248|  8.51k|    if (!fSchemaNamespaceId)
  ------------------
  |  Branch (1248:9): [True: 8.51k, False: 0]
  ------------------
 1249|  8.51k|        fSchemaNamespaceId  = fURIStringPool->addOrFind(SchemaSymbols::fgURI_XSI);
 1250|       |
 1251|       |    // Reset some status flags
 1252|  8.51k|    fInException = false;
 1253|  8.51k|    fStandalone = false;
 1254|  8.51k|    fErrorCount = 0;
 1255|  8.51k|    fHasNoDTD = true;
 1256|  8.51k|    fSeeXsi = false;
 1257|       |
 1258|       |    // Reset PSVI context
 1259|       |    // note that we always need this around for DOMTypeInfo
 1260|  8.51k|    if (!fPSVIElement)
  ------------------
  |  Branch (1260:9): [True: 8.51k, False: 0]
  ------------------
 1261|  8.51k|        fPSVIElement = new (fMemoryManager) PSVIElement(fMemoryManager);
 1262|       |
 1263|  8.51k|    if (!fErrorStack)
  ------------------
  |  Branch (1263:9): [True: 8.51k, False: 0]
  ------------------
 1264|  8.51k|    {
 1265|  8.51k|        fErrorStack = new (fMemoryManager) ValueStackOf<bool>(8, fMemoryManager);
 1266|  8.51k|    }
 1267|      0|    else
 1268|      0|    {
 1269|      0|        fErrorStack->removeAllElements();
 1270|      0|    }
 1271|       |
 1272|  8.51k|    resetPSVIElemContext();
 1273|       |
 1274|       |    // Reset the validators
 1275|  8.51k|    fDTDValidator->reset();
 1276|  8.51k|    fDTDValidator->setErrorReporter(fErrorReporter);
 1277|  8.51k|    fSchemaValidator->reset();
 1278|  8.51k|    fSchemaValidator->setErrorReporter(fErrorReporter);
 1279|  8.51k|    fSchemaValidator->setExitOnFirstFatal(fExitOnFirstFatal);
 1280|  8.51k|    fSchemaValidator->setGrammarResolver(fGrammarResolver);
 1281|  8.51k|    if (fValidatorFromUser)
  ------------------
  |  Branch (1281:9): [True: 0, False: 8.51k]
  ------------------
 1282|      0|        fValidator->reset();
 1283|       |
 1284|       |    //  Handle the creation of the XML reader object for this input source.
 1285|       |    //  This will provide us with transcoding and basic lexing services.
 1286|  8.51k|    XMLReader* newReader = fReaderMgr.createReader
 1287|  8.51k|    (
 1288|  8.51k|        src
 1289|  8.51k|        , true
 1290|  8.51k|        , XMLReader::RefFrom_NonLiteral
 1291|  8.51k|        , XMLReader::Type_General
 1292|  8.51k|        , XMLReader::Source_External
 1293|  8.51k|        , fCalculateSrcOfs
 1294|  8.51k|        , fLowWaterMark
 1295|  8.51k|    );
 1296|       |
 1297|  8.51k|    if (!newReader) {
  ------------------
  |  Branch (1297:9): [True: 0, False: 8.51k]
  ------------------
 1298|      0|        if (src.getIssueFatalErrorIfNotFound())
  ------------------
  |  Branch (1298:13): [True: 0, False: 0]
  ------------------
 1299|      0|            ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Scan_CouldNotOpenSource, src.getSystemId(), fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1300|      0|        else
 1301|      0|            ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Scan_CouldNotOpenSource_Warning, src.getSystemId(), fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1302|      0|    }
 1303|       |
 1304|       |    // Push this read onto the reader manager
 1305|  8.51k|    fReaderMgr.pushReader(newReader, 0);
 1306|       |
 1307|       |    // and reset security-related things if necessary:
 1308|  8.51k|    if(fSecurityManager != 0)
  ------------------
  |  Branch (1308:8): [True: 0, False: 8.51k]
  ------------------
 1309|      0|    {
 1310|      0|        fEntityExpansionLimit = fSecurityManager->getEntityExpansionLimit();
 1311|      0|        fEntityExpansionCount = 0;
 1312|      0|    }
 1313|  8.51k|    fElemCount = 0;
 1314|  8.51k|    if(fUIntPoolRowTotal >= 32)
  ------------------
  |  Branch (1314:8): [True: 0, False: 8.51k]
  ------------------
 1315|      0|    { // 8 KB tied up with validating attributes...
 1316|      0|        fAttDefRegistry->removeAll();
 1317|      0|        recreateUIntPool();
 1318|      0|    }
 1319|  8.51k|    else
 1320|  8.51k|    {
 1321|       |        // note that this will implicitly reset the values of the hashtables,
 1322|       |        // though their buckets will still be tied up
 1323|  8.51k|        resetUIntPool();
 1324|  8.51k|    }
 1325|  8.51k|    fUndeclaredAttrRegistry->removeAll();
 1326|  8.51k|    fDTDElemNonDeclPool->removeAll();
 1327|  8.51k|}
_ZN11xercesc_3_212IGXMLScanner12sendCharDataERNS_9XMLBufferE:
 1338|   697k|{
 1339|       |    // If no data in the buffer, then nothing to do
 1340|   697k|    if (toSend.isEmpty())
  ------------------
  |  Branch (1340:9): [True: 7.79k, False: 690k]
  ------------------
 1341|  7.79k|        return;
 1342|       |
 1343|       |    //  We do different things according to whether we are validating or
 1344|       |    //  not. If not, its always just characters; else, it depends on the
 1345|       |    //  current element's content model.
 1346|   690k|    if (fValidate)
  ------------------
  |  Branch (1346:9): [True: 690k, False: 0]
  ------------------
 1347|   690k|    {
 1348|       |        // Get the raw data we need for the callback
 1349|   690k|        const XMLCh* rawBuf = toSend.getRawBuffer();
 1350|   690k|        XMLSize_t len = toSend.getLen();
 1351|       |
 1352|       |        // And see if the current element is a 'Children' style content model
 1353|   690k|        const ElemStack::StackElem* topElem = fElemStack.topElement();
 1354|       |
 1355|       |        // Get the character data opts for the current element
 1356|   690k|        XMLElementDecl::CharDataOpts charOpts = XMLElementDecl::AllCharData;
 1357|   690k|        if(fGrammar->getGrammarType() == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (1357:12): [True: 0, False: 690k]
  ------------------
 1358|      0|        {
 1359|       |            // And see if the current element is a 'Children' style content model
 1360|      0|            ComplexTypeInfo *currType = ((SchemaValidator*)fValidator)->getCurrentTypeInfo();
 1361|      0|            if(currType)
  ------------------
  |  Branch (1361:16): [True: 0, False: 0]
  ------------------
 1362|      0|            {
 1363|      0|                SchemaElementDecl::ModelTypes modelType = (SchemaElementDecl::ModelTypes) currType->getContentType();
 1364|      0|                if(modelType == SchemaElementDecl::Children ||
  ------------------
  |  Branch (1364:20): [True: 0, False: 0]
  ------------------
 1365|      0|                   modelType == SchemaElementDecl::ElementOnlyEmpty)
  ------------------
  |  Branch (1365:20): [True: 0, False: 0]
  ------------------
 1366|      0|                    charOpts = XMLElementDecl::SpacesOk;
 1367|      0|                else if(modelType == SchemaElementDecl::Empty)
  ------------------
  |  Branch (1367:25): [True: 0, False: 0]
  ------------------
 1368|      0|                    charOpts = XMLElementDecl::NoCharData;
 1369|      0|            }
 1370|      0|        } else // DTD grammar
 1371|   690k|            charOpts = topElem->fThisElement->getCharDataOpts();
 1372|       |
 1373|   690k|        if (charOpts == XMLElementDecl::NoCharData)
  ------------------
  |  Branch (1373:13): [True: 4.89k, False: 685k]
  ------------------
 1374|  4.89k|        {
 1375|       |            // They definitely cannot handle any type of char data
 1376|  4.89k|            fValidator->emitError(XMLValid::NoCharDataInCM);
 1377|       |            //if(fGrammarType == Grammar::SchemaGrammarType)
 1378|       |            //{
 1379|       |              //  if (getPSVIHandler())
 1380|       |              //  {
 1381|       |                    // REVISIT:
 1382|       |                    // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
 1383|       |              //  }
 1384|       |           // }
 1385|  4.89k|        }
 1386|   685k|        else if (fReaderMgr.getCurrentReader()->isAllSpaces(rawBuf, len))
  ------------------
  |  Branch (1386:18): [True: 344k, False: 340k]
  ------------------
 1387|   344k|        {
 1388|       |            //  Its all spaces. So, if they can take spaces, then send it
 1389|       |            //  as ignorable whitespace. If they can handle any char data
 1390|       |            //  send it as characters.
 1391|   344k|            if (charOpts == XMLElementDecl::SpacesOk) {
  ------------------
  |  Branch (1391:17): [True: 3.94k, False: 340k]
  ------------------
 1392|  3.94k|                if (fDocHandler)
  ------------------
  |  Branch (1392:21): [True: 0, False: 3.94k]
  ------------------
 1393|      0|                    fDocHandler->ignorableWhitespace(rawBuf, len, false);
 1394|  3.94k|            }
 1395|   340k|            else if (charOpts == XMLElementDecl::AllCharData)
  ------------------
  |  Branch (1395:22): [True: 340k, False: 0]
  ------------------
 1396|   340k|            {
 1397|   340k|                if (fGrammarType != Grammar::SchemaGrammarType)
  ------------------
  |  Branch (1397:21): [True: 340k, False: 0]
  ------------------
 1398|   340k|                {
 1399|   340k|                    if (fDocHandler)
  ------------------
  |  Branch (1399:25): [True: 0, False: 340k]
  ------------------
 1400|      0|                        fDocHandler->docCharacters(rawBuf, len, false);
 1401|   340k|                }
 1402|      0|                else
 1403|      0|                {
 1404|      0|                    XMLSize_t xsLen;
 1405|      0|                    const XMLCh* xsNormalized;
 1406|      0|                    SchemaValidator *schemaValidator = (SchemaValidator *)fValidator;
 1407|      0|                    DatatypeValidator* tempDV = ((SchemaValidator*) fValidator)->getCurrentDatatypeValidator();
 1408|      0|                    if (tempDV && tempDV->getWSFacet() != DatatypeValidator::PRESERVE)
  ------------------
  |  Branch (1408:25): [True: 0, False: 0]
  |  Branch (1408:35): [True: 0, False: 0]
  ------------------
 1409|      0|                    {
 1410|       |                        // normalize the character according to schema whitespace facet
 1411|      0|                        ((SchemaValidator*) fValidator)->normalizeWhiteSpace(tempDV, rawBuf, fWSNormalizeBuf);
 1412|      0|                        xsNormalized = fWSNormalizeBuf.getRawBuffer();
 1413|      0|                        xsLen = fWSNormalizeBuf.getLen();
 1414|      0|                    }
 1415|      0|                    else {
 1416|      0|                        xsNormalized = rawBuf;
 1417|      0|                        xsLen = len ;
 1418|      0|                    }
 1419|       |
 1420|       |                    // tell the schema validation about the character data for checkContent later
 1421|      0|                    schemaValidator->setDatatypeBuffer(xsNormalized);
 1422|       |
 1423|       |                    // call all active identity constraints
 1424|      0|                    if (toCheckIdentityConstraint() && fICHandler->getMatcherCount()) {
  ------------------
  |  Branch (1424:25): [True: 0, False: 0]
  |  Branch (1424:56): [True: 0, False: 0]
  ------------------
 1425|      0|                        fContent.append(xsNormalized, xsLen);
 1426|      0|                    }
 1427|       |
 1428|      0|                    if (fDocHandler) {
  ------------------
  |  Branch (1428:25): [True: 0, False: 0]
  ------------------
 1429|      0|                        if (fNormalizeData) {
  ------------------
  |  Branch (1429:29): [True: 0, False: 0]
  ------------------
 1430|      0|                           fDocHandler->docCharacters(xsNormalized, xsLen, false);
 1431|      0|                        }
 1432|      0|                        else {
 1433|      0|                            fDocHandler->docCharacters(rawBuf, len, false);
 1434|      0|                        }
 1435|      0|                    }
 1436|      0|                }
 1437|   340k|            }
 1438|   344k|        }
 1439|   340k|        else
 1440|   340k|        {
 1441|       |            //  If they can take any char data, then send it. Otherwise, they
 1442|       |            //  can only handle whitespace and can't handle this stuff so
 1443|       |            //  issue an error.
 1444|   340k|            if (charOpts == XMLElementDecl::AllCharData)
  ------------------
  |  Branch (1444:17): [True: 315k, False: 25.1k]
  ------------------
 1445|   315k|            {
 1446|   315k|                if (fGrammarType != Grammar::SchemaGrammarType)
  ------------------
  |  Branch (1446:21): [True: 315k, False: 0]
  ------------------
 1447|   315k|                {
 1448|   315k|                    if (fDocHandler)
  ------------------
  |  Branch (1448:25): [True: 0, False: 315k]
  ------------------
 1449|      0|                        fDocHandler->docCharacters(rawBuf, len, false);
 1450|   315k|                }
 1451|      0|                else
 1452|      0|                {
 1453|      0|                    XMLSize_t xsLen;
 1454|      0|                    const XMLCh* xsNormalized;
 1455|      0|                    SchemaValidator *schemaValidator = (SchemaValidator*)fValidator;
 1456|      0|                    DatatypeValidator* tempDV = ((SchemaValidator*) fValidator)->getCurrentDatatypeValidator();
 1457|      0|                    if (tempDV && tempDV->getWSFacet() != DatatypeValidator::PRESERVE)
  ------------------
  |  Branch (1457:25): [True: 0, False: 0]
  |  Branch (1457:35): [True: 0, False: 0]
  ------------------
 1458|      0|                    {
 1459|       |                        // normalize the character according to schema whitespace facet
 1460|      0|                        ((SchemaValidator*) fValidator)->normalizeWhiteSpace(tempDV, rawBuf, fWSNormalizeBuf);
 1461|      0|                        xsNormalized = fWSNormalizeBuf.getRawBuffer();
 1462|      0|                        xsLen = fWSNormalizeBuf.getLen();
 1463|      0|                    }
 1464|      0|                    else {
 1465|      0|                        xsNormalized = rawBuf;
 1466|      0|                        xsLen = len;
 1467|      0|                    }
 1468|       |
 1469|       |                    // tell the schema validation about the character data for checkContent later
 1470|      0|                    schemaValidator->setDatatypeBuffer(xsNormalized);
 1471|       |
 1472|       |                    // call all active identity constraints
 1473|      0|                    if (toCheckIdentityConstraint() && fICHandler->getMatcherCount()) {
  ------------------
  |  Branch (1473:25): [True: 0, False: 0]
  |  Branch (1473:56): [True: 0, False: 0]
  ------------------
 1474|      0|                        fContent.append(xsNormalized, xsLen);
 1475|      0|                    }
 1476|       |
 1477|      0|                    if (fDocHandler) {
  ------------------
  |  Branch (1477:25): [True: 0, False: 0]
  ------------------
 1478|      0|                        if (fNormalizeData) {
  ------------------
  |  Branch (1478:29): [True: 0, False: 0]
  ------------------
 1479|      0|                            fDocHandler->docCharacters(xsNormalized, xsLen, false);
 1480|      0|                        }
 1481|      0|                        else {
 1482|      0|                            fDocHandler->docCharacters(rawBuf, len, false);
 1483|      0|                        }
 1484|      0|                    }
 1485|      0|                }
 1486|   315k|            }
 1487|  25.1k|            else
 1488|  25.1k|            {
 1489|  25.1k|                fValidator->emitError(XMLValid::NoCharDataInCM);
 1490|  25.1k|                if(fGrammarType == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (1490:20): [True: 0, False: 25.1k]
  ------------------
 1491|      0|                {
 1492|      0|                    if (getPSVIHandler())
  ------------------
  |  Branch (1492:25): [True: 0, False: 0]
  ------------------
 1493|      0|                    {
 1494|       |                        // REVISIT:
 1495|       |                        // PSVIAttribute->setValidity(PSVIItem::VALIDITY_INVALID);
 1496|      0|                    }
 1497|      0|                }
 1498|  25.1k|            }
 1499|   340k|        }
 1500|   690k|    }
 1501|      0|    else
 1502|      0|    {
 1503|       |        // call all active identity constraints
 1504|      0|        if (fGrammarType == Grammar::SchemaGrammarType) {
  ------------------
  |  Branch (1504:13): [True: 0, False: 0]
  ------------------
 1505|       |
 1506|      0|            if (toCheckIdentityConstraint() && fICHandler->getMatcherCount())
  ------------------
  |  Branch (1506:17): [True: 0, False: 0]
  |  Branch (1506:48): [True: 0, False: 0]
  ------------------
 1507|      0|                fContent.append(toSend.getRawBuffer(), toSend.getLen());
 1508|      0|        }
 1509|       |
 1510|       |        // Always assume its just char data if not validating
 1511|      0|        if (fDocHandler)
  ------------------
  |  Branch (1511:13): [True: 0, False: 0]
  ------------------
 1512|      0|            fDocHandler->docCharacters(toSend.getRawBuffer(), toSend.getLen(), false);
 1513|      0|    }
 1514|       |
 1515|       |    // Reset buffer
 1516|   690k|    toSend.reset();
 1517|   690k|}
_ZN11xercesc_3_212IGXMLScanner12scanAttValueEPKNS_9XMLAttDefEPKDsRNS_9XMLBufferE:
 2407|   473k|{
 2408|   473k|    enum States
 2409|   473k|    {
 2410|   473k|        InWhitespace
 2411|   473k|        , InContent
 2412|   473k|    };
 2413|       |
 2414|       |    // Get the type and name
 2415|   473k|    const XMLAttDef::AttTypes type = (attDef)
  ------------------
  |  Branch (2415:38): [True: 9.41k, False: 464k]
  ------------------
 2416|   473k|                ?attDef->getType()
 2417|   473k|                :XMLAttDef::CData;
 2418|       |
 2419|       |    // Reset the target buffer
 2420|   473k|    toFill.reset();
 2421|       |
 2422|       |    // Get the next char which must be a single or double quote
 2423|   473k|    XMLCh quoteCh;
 2424|   473k|    if (!fReaderMgr.skipIfQuote(quoteCh))
  ------------------
  |  Branch (2424:9): [True: 23, False: 473k]
  ------------------
 2425|     23|        return false;
 2426|       |
 2427|       |    //  We have to get the current reader because we have to ignore closing
 2428|       |    //  quotes until we hit the same reader again.
 2429|   473k|    const XMLSize_t curReader = fReaderMgr.getCurrentReaderNum();
 2430|       |
 2431|       |    // check to see if it's a tokenized type that is declared externally 
 2432|   473k|    bool  isAttTokenizedExternal = (attDef)
  ------------------
  |  Branch (2432:36): [True: 9.40k, False: 464k]
  ------------------
 2433|   473k|                                   ?attDef->isExternal() && (type == XMLAttDef::ID || 
  ------------------
  |  Branch (2433:37): [True: 0, False: 9.40k]
  |  Branch (2433:62): [True: 0, False: 0]
  ------------------
 2434|      0|                                                             type == XMLAttDef::IDRef || 
  ------------------
  |  Branch (2434:62): [True: 0, False: 0]
  ------------------
 2435|      0|                                                             type == XMLAttDef::IDRefs || 
  ------------------
  |  Branch (2435:62): [True: 0, False: 0]
  ------------------
 2436|      0|                                                             type == XMLAttDef::Entity || 
  ------------------
  |  Branch (2436:62): [True: 0, False: 0]
  ------------------
 2437|      0|                                                             type == XMLAttDef::Entities || 
  ------------------
  |  Branch (2437:62): [True: 0, False: 0]
  ------------------
 2438|      0|                                                             type == XMLAttDef::NmToken || 
  ------------------
  |  Branch (2438:62): [True: 0, False: 0]
  ------------------
 2439|      0|                                                             type == XMLAttDef::NmTokens)
  ------------------
  |  Branch (2439:62): [True: 0, False: 0]
  ------------------
 2440|   473k|                                   :false;
 2441|       |
 2442|       |    //  Loop until we get the attribute value. Note that we use a double
 2443|       |    //  loop here to avoid the setup/teardown overhead of the exception
 2444|       |    //  handler on every round.
 2445|   473k|    XMLCh   nextCh;
 2446|   473k|    XMLCh   secondCh = 0;
 2447|   473k|    States  curState = InContent;
 2448|   473k|    bool    firstNonWS = false;
 2449|   473k|    bool    gotLeadingSurrogate = false;
 2450|   473k|    bool    escaped;
 2451|   473k|    while (true)
  ------------------
  |  Branch (2451:12): [Folded - Ignored]
  ------------------
 2452|   473k|    {
 2453|   473k|        try
 2454|   473k|        {
 2455|  13.8M|            while(true)
  ------------------
  |  Branch (2455:19): [Folded - Ignored]
  ------------------
 2456|  13.8M|            {
 2457|  13.8M|                nextCh = fReaderMgr.getNextChar();
 2458|       |
 2459|  13.8M|                if (!nextCh)
  ------------------
  |  Branch (2459:21): [True: 61, False: 13.8M]
  ------------------
 2460|     61|                    ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|     61|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 2461|       |
 2462|       |                // Check for our ending quote in the same entity
 2463|  13.8M|                if (nextCh == quoteCh)
  ------------------
  |  Branch (2463:21): [True: 474k, False: 13.3M]
  ------------------
 2464|   474k|                {
 2465|   474k|                    if (curReader == fReaderMgr.getCurrentReaderNum())
  ------------------
  |  Branch (2465:25): [True: 473k, False: 1.47k]
  ------------------
 2466|   473k|                        return true;
 2467|       |
 2468|       |                    // Watch for spillover into a previous entity
 2469|  1.47k|                    if (curReader > fReaderMgr.getCurrentReaderNum())
  ------------------
  |  Branch (2469:25): [True: 2, False: 1.47k]
  ------------------
 2470|      2|                    {
 2471|      2|                        emitError(XMLErrs::PartialMarkupInEntity);
 2472|      2|                        return false;
 2473|      2|                    }
 2474|  1.47k|                }
 2475|       |
 2476|       |                //  Check for an entity ref now, before we let it affect our
 2477|       |                //  whitespace normalization logic below. We ignore the empty flag
 2478|       |                //  in this one.
 2479|  13.3M|                escaped = false;
 2480|  13.3M|                if (nextCh == chAmpersand)
  ------------------
  |  Branch (2480:21): [True: 13.1k, False: 13.3M]
  ------------------
 2481|  13.1k|                {
 2482|  13.1k|                    if (scanEntityRef(true, nextCh, secondCh, escaped) != EntityExp_Returned)
  ------------------
  |  Branch (2482:25): [True: 4.85k, False: 8.29k]
  ------------------
 2483|  4.85k|                    {
 2484|  4.85k|                        gotLeadingSurrogate = false;
 2485|  4.85k|                        continue;
 2486|  4.85k|                    }
 2487|  13.1k|                }
 2488|  13.3M|                else if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (2488:26): [True: 1.06k, False: 13.3M]
  |  Branch (2488:48): [True: 252, False: 816]
  ------------------
 2489|    252|                {
 2490|       |                    // Deal with surrogate pairs
 2491|       |                    //  Its a leading surrogate. If we already got one, then
 2492|       |                    //  issue an error, else set leading flag to make sure that
 2493|       |                    //  we look for a trailing next time.
 2494|    252|                    if (gotLeadingSurrogate)
  ------------------
  |  Branch (2494:25): [True: 0, False: 252]
  ------------------
 2495|      0|                        emitError(XMLErrs::Expected2ndSurrogateChar);
 2496|    252|                     else
 2497|    252|                        gotLeadingSurrogate = true;
 2498|    252|                }
 2499|  13.3M|                else
 2500|  13.3M|                {
 2501|       |                    //  If its a trailing surrogate, make sure that we are
 2502|       |                    //  prepared for that. Else, its just a regular char so make
 2503|       |                    //  sure that we were not expected a trailing surrogate.
 2504|  13.3M|                    if ((nextCh >= 0xDC00) && (nextCh <= 0xDFFF))
  ------------------
  |  Branch (2504:25): [True: 816, False: 13.3M]
  |  Branch (2504:47): [True: 252, False: 564]
  ------------------
 2505|    252|                    {
 2506|       |                        // Its trailing, so make sure we were expecting it
 2507|    252|                        if (!gotLeadingSurrogate)
  ------------------
  |  Branch (2507:29): [True: 0, False: 252]
  ------------------
 2508|      0|                            emitError(XMLErrs::Unexpected2ndSurrogateChar);
 2509|    252|                    }
 2510|  13.3M|                    else
 2511|  13.3M|                    {
 2512|       |                        //  Its just a char, so make sure we were not expecting a
 2513|       |                        //  trailing surrogate.
 2514|  13.3M|                        if (gotLeadingSurrogate)
  ------------------
  |  Branch (2514:29): [True: 0, False: 13.3M]
  ------------------
 2515|      0|                            emitError(XMLErrs::Expected2ndSurrogateChar);
 2516|       |
 2517|       |                        // Its got to at least be a valid XML character
 2518|  13.3M|                        if (!fReaderMgr.getCurrentReader()->isXMLChar(nextCh))
  ------------------
  |  Branch (2518:29): [True: 12, False: 13.3M]
  ------------------
 2519|     12|                        {
 2520|     12|                            XMLCh tmpBuf[9];
 2521|     12|                            XMLString::binToText
 2522|     12|                            (
 2523|     12|                                nextCh
 2524|     12|                                , tmpBuf
 2525|     12|                                , 8
 2526|     12|                                , 16
 2527|     12|                                , fMemoryManager
 2528|     12|                            );
 2529|     12|                            emitError(XMLErrs::InvalidCharacterInAttrValue, attrName, tmpBuf);
 2530|     12|                        }
 2531|  13.3M|                    }
 2532|  13.3M|                    gotLeadingSurrogate = false;
 2533|  13.3M|                }
 2534|       |
 2535|       |                //  If its not escaped, then make sure its not a < character, which
 2536|       |                //  is not allowed in attribute values.
 2537|  13.3M|                if (!escaped && (nextCh == chOpenAngle))
  ------------------
  |  Branch (2537:21): [True: 13.3M, False: 8.31k]
  |  Branch (2537:33): [True: 11, False: 13.3M]
  ------------------
 2538|     11|                    emitError(XMLErrs::BracketInAttrValue, attrName);
 2539|       |
 2540|       |                //  If the attribute is a CDATA type we do simple replacement of
 2541|       |                //  tabs and new lines with spaces, if the character is not escaped
 2542|       |                //  by way of a char ref.
 2543|       |                //
 2544|       |                //  Otherwise, we do the standard non-CDATA normalization of
 2545|       |                //  compressing whitespace to single spaces and getting rid of leading
 2546|       |                //  and trailing whitespace.
 2547|  13.3M|                if (type == XMLAttDef::CData)
  ------------------
  |  Branch (2547:21): [True: 13.0M, False: 278k]
  ------------------
 2548|  13.0M|                {
 2549|  13.0M|                    if (!escaped)
  ------------------
  |  Branch (2549:25): [True: 13.0M, False: 1.65k]
  ------------------
 2550|  13.0M|                    {
 2551|  13.0M|                        if ((nextCh == 0x09) || (nextCh == 0x0A) || (nextCh == 0x0D))
  ------------------
  |  Branch (2551:29): [True: 260k, False: 12.7M]
  |  Branch (2551:49): [True: 210k, False: 12.5M]
  |  Branch (2551:69): [True: 215, False: 12.5M]
  ------------------
 2552|   470k|                        {
 2553|       |                            // Check Validity Constraint for Standalone document declaration
 2554|       |                            // XML 1.0, Section 2.9
 2555|   470k|                            if (fStandalone && fValidate && isAttTokenizedExternal)
  ------------------
  |  Branch (2555:33): [True: 7.05k, False: 463k]
  |  Branch (2555:48): [True: 7.05k, False: 0]
  |  Branch (2555:61): [True: 0, False: 7.05k]
  ------------------
 2556|      0|                            {
 2557|       |                                // Can't have a standalone document declaration of "yes" if  attribute
 2558|       |                                // values are subject to normalisation
 2559|      0|                                fValidator->emitError(XMLValid::NoAttNormForStandalone, attrName);
 2560|      0|                            }
 2561|   470k|                            nextCh = chSpace;
 2562|   470k|                        }
 2563|  13.0M|                    }
 2564|  13.0M|                }
 2565|   278k|                else
 2566|   278k|                {
 2567|   278k|                    if (curState == InWhitespace)
  ------------------
  |  Branch (2567:25): [True: 61.5k, False: 216k]
  ------------------
 2568|  61.5k|                    {
 2569|  61.5k|                        if ((escaped && nextCh != chSpace) || !fReaderMgr.getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (2569:30): [True: 4.71k, False: 56.8k]
  |  Branch (2569:41): [True: 4.50k, False: 209]
  |  Branch (2569:63): [True: 28.1k, False: 28.8k]
  ------------------
 2570|  32.6k|                        {
 2571|  32.6k|                            if (firstNonWS)
  ------------------
  |  Branch (2571:33): [True: 28.6k, False: 4.07k]
  ------------------
 2572|  28.6k|                                toFill.append(chSpace);
 2573|  32.6k|                            curState = InContent;
 2574|  32.6k|                            firstNonWS = true;
 2575|  32.6k|                        }
 2576|  28.8k|                        else
 2577|  28.8k|                        {
 2578|  28.8k|                            continue;
 2579|  28.8k|                        }
 2580|  61.5k|                    }
 2581|   216k|                    else if (curState == InContent)
  ------------------
  |  Branch (2581:30): [True: 216k, False: 65]
  ------------------
 2582|   216k|                    {
 2583|   216k|                        if ((nextCh == chSpace) ||
  ------------------
  |  Branch (2583:29): [True: 21.9k, False: 194k]
  ------------------
 2584|   216k|                            (fReaderMgr.getCurrentReader()->isWhitespace(nextCh) && !escaped))
  ------------------
  |  Branch (2584:30): [True: 17.4k, False: 177k]
  |  Branch (2584:85): [True: 15.5k, False: 1.85k]
  ------------------
 2585|  37.5k|                        {
 2586|  37.5k|                            curState = InWhitespace;
 2587|       |
 2588|       |                            // Check Validity Constraint for Standalone document declaration
 2589|       |                            // XML 1.0, Section 2.9
 2590|  37.5k|                            if (fStandalone && fValidate && isAttTokenizedExternal)
  ------------------
  |  Branch (2590:33): [True: 34.5k, False: 3.03k]
  |  Branch (2590:48): [True: 34.5k, False: 0]
  |  Branch (2590:61): [True: 0, False: 34.5k]
  ------------------
 2591|      0|                            {
 2592|      0|                                if (!firstNonWS || (nextCh != chSpace && fReaderMgr.lookingAtSpace()))
  ------------------
  |  Branch (2592:37): [True: 0, False: 0]
  |  Branch (2592:53): [True: 0, False: 0]
  |  Branch (2592:74): [True: 0, False: 0]
  ------------------
 2593|      0|                                {
 2594|       |                                     // Can't have a standalone document declaration of "yes" if  attribute
 2595|       |                                     // values are subject to normalisation
 2596|      0|                                     fValidator->emitError(XMLValid::NoAttNormForStandalone, attrName);
 2597|      0|                                }
 2598|      0|                            }
 2599|  37.5k|                            continue;
 2600|  37.5k|                        }
 2601|   179k|                        firstNonWS = true;
 2602|   179k|                    }
 2603|   278k|                }
 2604|       |
 2605|       |                // Else add it to the buffer
 2606|  13.2M|                toFill.append(nextCh);
 2607|       |
 2608|  13.2M|                if (secondCh)
  ------------------
  |  Branch (2608:21): [True: 308, False: 13.2M]
  ------------------
 2609|    308|                {
 2610|    308|                    toFill.append(secondCh);
 2611|    308|                    secondCh=0;
 2612|    308|                }
 2613|  13.2M|            }
 2614|   473k|        }
 2615|   473k|        catch(const EndOfEntityException&)
 2616|   473k|        {
 2617|       |            // Just eat it and continue.
 2618|      0|            gotLeadingSurrogate = false;
 2619|      0|            escaped = false;
 2620|      0|        }
 2621|   473k|    }
 2622|      0|    return true;
 2623|   473k|}
_ZN11xercesc_3_212IGXMLScanner13scanCDSectionEv:
 2631|  1.37k|{
 2632|  1.37k|    static const XMLCh CDataClose[] =
 2633|  1.37k|    {
 2634|  1.37k|            chCloseSquare, chCloseAngle, chNull
 2635|  1.37k|    };
 2636|       |
 2637|       |    //  The next character should be the opening square bracket. If not
 2638|       |    //  issue an error, but then try to recover by skipping any whitespace
 2639|       |    //  and checking again.
 2640|  1.37k|    if (!fReaderMgr.skippedChar(chOpenSquare))
  ------------------
  |  Branch (2640:9): [True: 0, False: 1.37k]
  ------------------
 2641|      0|    {
 2642|      0|        emitError(XMLErrs::ExpectedOpenSquareBracket);
 2643|      0|        fReaderMgr.skipPastSpaces();
 2644|       |
 2645|       |        // If we still don't find it, then give up, else keep going
 2646|      0|        if (!fReaderMgr.skippedChar(chOpenSquare))
  ------------------
  |  Branch (2646:13): [True: 0, False: 0]
  ------------------
 2647|      0|            return;
 2648|      0|    }
 2649|       |
 2650|       |    // Get a buffer for this
 2651|  1.37k|    XMLBufBid bbCData(&fBufMgr);
 2652|       |
 2653|       |    //  We just scan forward until we hit the end of CDATA section sequence.
 2654|       |    //  CDATA is effectively a big escape mechanism so we don't treat markup
 2655|       |    //  characters specially here.
 2656|  1.37k|    bool            emittedError = false;
 2657|  1.37k|    bool    gotLeadingSurrogate = false;
 2658|  1.37k|    const ElemStack::StackElem* topElem = fElemStack.topElement();
 2659|       |
 2660|       |    // Get the character data opts for the current element
 2661|  1.37k|    XMLElementDecl::CharDataOpts charOpts = XMLElementDecl::AllCharData;
 2662|  1.37k|    if(fGrammar->getGrammarType() == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (2662:8): [True: 0, False: 1.37k]
  ------------------
 2663|      0|    {
 2664|       |        // And see if the current element is a 'Children' style content model
 2665|      0|        ComplexTypeInfo *currType = ((SchemaValidator*)fValidator)->getCurrentTypeInfo();
 2666|      0|        if(currType)
  ------------------
  |  Branch (2666:12): [True: 0, False: 0]
  ------------------
 2667|      0|        {
 2668|      0|            SchemaElementDecl::ModelTypes modelType = (SchemaElementDecl::ModelTypes) currType->getContentType();
 2669|      0|            if(modelType == SchemaElementDecl::Children ||
  ------------------
  |  Branch (2669:16): [True: 0, False: 0]
  ------------------
 2670|      0|               modelType == SchemaElementDecl::ElementOnlyEmpty)
  ------------------
  |  Branch (2670:16): [True: 0, False: 0]
  ------------------
 2671|      0|                charOpts = XMLElementDecl::SpacesOk;
 2672|      0|            else if(modelType == SchemaElementDecl::Empty)
  ------------------
  |  Branch (2672:21): [True: 0, False: 0]
  ------------------
 2673|      0|                charOpts = XMLElementDecl::NoCharData;
 2674|      0|        }
 2675|      0|    } else // DTD grammar
 2676|  1.37k|        charOpts = topElem->fThisElement->getCharDataOpts();
 2677|       |
 2678|   344k|    while (true)
  ------------------
  |  Branch (2678:12): [Folded - Ignored]
  ------------------
 2679|   344k|    {
 2680|   344k|        const XMLCh nextCh = fReaderMgr.getNextChar();
 2681|       |
 2682|       |        // Watch for unexpected end of file
 2683|   344k|        if (!nextCh)
  ------------------
  |  Branch (2683:13): [True: 6, False: 344k]
  ------------------
 2684|      6|        {
 2685|      6|            emitError(XMLErrs::UnterminatedCDATASection);
 2686|      6|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      6|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 2687|      6|        }
 2688|       |
 2689|   344k|        if (fValidate && fStandalone && (fReaderMgr.getCurrentReader()->isWhitespace(nextCh)))
  ------------------
  |  Branch (2689:13): [True: 344k, False: 0]
  |  Branch (2689:26): [True: 316k, False: 27.8k]
  |  Branch (2689:41): [True: 476, False: 316k]
  ------------------
 2690|    476|        {
 2691|       |            // This document is standalone; this ignorable CDATA whitespace is forbidden.
 2692|       |            // XML 1.0, Section 2.9
 2693|       |            // And see if the current element is a 'Children' style content model
 2694|    476|            if (topElem->fThisElement->isExternal()) {
  ------------------
  |  Branch (2694:17): [True: 242, False: 234]
  ------------------
 2695|       |
 2696|    242|                if (charOpts == XMLElementDecl::SpacesOk) // Element Content
  ------------------
  |  Branch (2696:21): [True: 0, False: 242]
  ------------------
 2697|      0|                {
 2698|       |                    // Error - standalone should have a value of "no" as whitespace detected in an
 2699|       |                    // element type with element content whose element declaration was external
 2700|      0|                    fValidator->emitError(XMLValid::NoWSForStandalone);
 2701|      0|                    if(fGrammarType == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (2701:24): [True: 0, False: 0]
  ------------------
 2702|      0|                    {
 2703|      0|                        if (getPSVIHandler())
  ------------------
  |  Branch (2703:29): [True: 0, False: 0]
  ------------------
 2704|      0|                        {
 2705|       |                            // REVISIT:
 2706|       |                            // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
 2707|      0|                        }
 2708|      0|                    }
 2709|      0|                }
 2710|    242|            }
 2711|    476|        }
 2712|       |
 2713|       |        //  If this is a close square bracket it could be our closing
 2714|       |        //  sequence.
 2715|   344k|        if (nextCh == chCloseSquare && fReaderMgr.skippedString(CDataClose))
  ------------------
  |  Branch (2715:13): [True: 1.53k, False: 343k]
  |  Branch (2715:40): [True: 1.36k, False: 173]
  ------------------
 2716|  1.36k|        {
 2717|       |            //  make sure we were not expecting a trailing surrogate.
 2718|  1.36k|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (2718:17): [True: 0, False: 1.36k]
  ------------------
 2719|      0|                emitError(XMLErrs::Expected2ndSurrogateChar);
 2720|       |
 2721|  1.36k|            if (fGrammarType == Grammar::SchemaGrammarType) {
  ------------------
  |  Branch (2721:17): [True: 0, False: 1.36k]
  ------------------
 2722|       |
 2723|      0|                XMLSize_t xsLen = bbCData.getLen();
 2724|      0|                const XMLCh* xsNormalized = bbCData.getRawBuffer();
 2725|      0|                DatatypeValidator* tempDV = ((SchemaValidator*) fValidator)->getCurrentDatatypeValidator();
 2726|      0|                if (tempDV && tempDV->getWSFacet() != DatatypeValidator::PRESERVE)
  ------------------
  |  Branch (2726:21): [True: 0, False: 0]
  |  Branch (2726:31): [True: 0, False: 0]
  ------------------
 2727|      0|                {
 2728|       |                    // normalize the character according to schema whitespace facet
 2729|      0|                    ((SchemaValidator*) fValidator)->normalizeWhiteSpace(tempDV, xsNormalized, fWSNormalizeBuf);
 2730|      0|                    xsNormalized = fWSNormalizeBuf.getRawBuffer();
 2731|      0|                    xsLen = fWSNormalizeBuf.getLen();
 2732|      0|                    if (fNormalizeData && fValidate) {
  ------------------
  |  Branch (2732:25): [True: 0, False: 0]
  |  Branch (2732:43): [True: 0, False: 0]
  ------------------
 2733|      0|                        bbCData.set(xsNormalized);
 2734|      0|                    }
 2735|      0|                }
 2736|       |
 2737|      0|                if (fValidate) {
  ------------------
  |  Branch (2737:21): [True: 0, False: 0]
  ------------------
 2738|       |
 2739|       |                    // tell the schema validation about the character data for checkContent later
 2740|      0|                    ((SchemaValidator*)fValidator)->setDatatypeBuffer(xsNormalized);
 2741|       |
 2742|      0|                    if (charOpts != XMLElementDecl::AllCharData)
  ------------------
  |  Branch (2742:25): [True: 0, False: 0]
  ------------------
 2743|      0|                    {
 2744|       |                        // They definitely cannot handle any type of char data
 2745|      0|                        fValidator->emitError(XMLValid::NoCharDataInCM);
 2746|      0|                        if (getPSVIHandler())
  ------------------
  |  Branch (2746:29): [True: 0, False: 0]
  ------------------
 2747|      0|                        {
 2748|       |                            // REVISIT:
 2749|       |                            // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
 2750|      0|                        }
 2751|      0|                    }
 2752|      0|                }
 2753|       |
 2754|       |                // call all active identity constraints
 2755|      0|                if (toCheckIdentityConstraint() && fICHandler->getMatcherCount()) {
  ------------------
  |  Branch (2755:21): [True: 0, False: 0]
  |  Branch (2755:52): [True: 0, False: 0]
  ------------------
 2756|      0|                    fContent.append(xsNormalized, xsLen);
 2757|      0|                }
 2758|      0|            }
 2759|  1.36k|            else {
 2760|  1.36k|                if (fValidate) {
  ------------------
  |  Branch (2760:21): [True: 1.36k, False: 0]
  ------------------
 2761|       |
 2762|  1.36k|                    if (charOpts != XMLElementDecl::AllCharData)
  ------------------
  |  Branch (2762:25): [True: 71, False: 1.29k]
  ------------------
 2763|     71|                    {
 2764|       |                        // They definitely cannot handle any type of char data
 2765|     71|                        fValidator->emitError(XMLValid::NoCharDataInCM);
 2766|     71|                    }
 2767|  1.36k|                }
 2768|  1.36k|            }
 2769|       |
 2770|       |            // If we have a doc handler, call it
 2771|  1.36k|            if (fDocHandler)
  ------------------
  |  Branch (2771:17): [True: 0, False: 1.36k]
  ------------------
 2772|      0|            {
 2773|      0|                fDocHandler->docCharacters(
 2774|      0|                    bbCData.getRawBuffer(), bbCData.getLen(), true
 2775|      0|                );
 2776|      0|            }
 2777|       |
 2778|       |            // And we are done
 2779|  1.36k|            break;
 2780|  1.36k|        }
 2781|       |
 2782|       |        //  Make sure its a valid character. But if we've emitted an error
 2783|       |        //  already, don't bother with the overhead since we've already told
 2784|       |        //  them about it.
 2785|   343k|        if (!emittedError)
  ------------------
  |  Branch (2785:13): [True: 343k, False: 1]
  ------------------
 2786|   343k|        {
 2787|       |            // Deal with surrogate pairs
 2788|   343k|            if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (2788:17): [True: 0, False: 343k]
  |  Branch (2788:39): [True: 0, False: 0]
  ------------------
 2789|      0|            {
 2790|       |                //  Its a leading surrogate. If we already got one, then
 2791|       |                //  issue an error, else set leading flag to make sure that
 2792|       |                //  we look for a trailing next time.
 2793|      0|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (2793:21): [True: 0, False: 0]
  ------------------
 2794|      0|                    emitError(XMLErrs::Expected2ndSurrogateChar);
 2795|      0|                else
 2796|      0|                    gotLeadingSurrogate = true;
 2797|      0|            }
 2798|   343k|            else
 2799|   343k|            {
 2800|       |                //  If its a trailing surrogate, make sure that we are
 2801|       |                //  prepared for that. Else, its just a regular char so make
 2802|       |                //  sure that we were not expected a trailing surrogate.
 2803|   343k|                if ((nextCh >= 0xDC00) && (nextCh <= 0xDFFF))
  ------------------
  |  Branch (2803:21): [True: 0, False: 343k]
  |  Branch (2803:43): [True: 0, False: 0]
  ------------------
 2804|      0|                {
 2805|       |                    // Its trailing, so make sure we were expecting it
 2806|      0|                    if (!gotLeadingSurrogate)
  ------------------
  |  Branch (2806:25): [True: 0, False: 0]
  ------------------
 2807|      0|                        emitError(XMLErrs::Unexpected2ndSurrogateChar);
 2808|      0|                }
 2809|   343k|                else
 2810|   343k|                {
 2811|       |                    //  Its just a char, so make sure we were not expecting a
 2812|       |                    //  trailing surrogate.
 2813|   343k|                    if (gotLeadingSurrogate)
  ------------------
  |  Branch (2813:25): [True: 0, False: 343k]
  ------------------
 2814|      0|                        emitError(XMLErrs::Expected2ndSurrogateChar);
 2815|       |
 2816|       |                    // Its got to at least be a valid XML character
 2817|   343k|                    else if (!fReaderMgr.getCurrentReader()->isXMLChar(nextCh))
  ------------------
  |  Branch (2817:30): [True: 4, False: 343k]
  ------------------
 2818|      4|                    {
 2819|      4|                        XMLCh tmpBuf[9];
 2820|      4|                        XMLString::binToText
 2821|      4|                        (
 2822|      4|                            nextCh
 2823|      4|                            , tmpBuf
 2824|      4|                            , 8
 2825|      4|                            , 16
 2826|      4|                            , fMemoryManager
 2827|      4|                        );
 2828|      4|                        emitError(XMLErrs::InvalidCharacter, tmpBuf);
 2829|      4|                        emittedError = true;
 2830|      4|                    }
 2831|   343k|                }
 2832|   343k|                gotLeadingSurrogate = false;
 2833|   343k|            }
 2834|   343k|        }
 2835|       |
 2836|       |        // Add it to the buffer
 2837|   343k|        bbCData.append(nextCh);
 2838|   343k|    }
 2839|  1.37k|}
_ZN11xercesc_3_212IGXMLScanner12scanCharDataERNS_9XMLBufferE:
 2843|   688k|{
 2844|       |    //  We have to watch for the stupid ]]> sequence, which is illegal in
 2845|       |    //  character data. So this is a little state machine that handles that.
 2846|   688k|    enum States
 2847|   688k|    {
 2848|   688k|        State_Waiting
 2849|   688k|        , State_GotOne
 2850|   688k|        , State_GotTwo
 2851|   688k|    };
 2852|       |
 2853|       |    // Reset the buffer before we start
 2854|   688k|    toUse.reset();
 2855|       |
 2856|       |    // Turn on the 'throw at end' flag of the reader manager
 2857|   688k|    ThrowEOEJanitor jan(&fReaderMgr, true);
 2858|       |
 2859|       |    //  In order to be more efficient we have to use kind of a deeply nested
 2860|       |    //  set of blocks here. The outer block puts on a try and catches end of
 2861|       |    //  entity exceptions. The inner loop is the per-character loop. If we
 2862|       |    //  put the try inside the inner loop, it would work but would require
 2863|       |    //  the exception handling code setup/teardown code to be invoked for
 2864|       |    //  each character.
 2865|   688k|    XMLCh   nextCh;
 2866|   688k|    XMLCh   secondCh = 0;
 2867|   688k|    States  curState = State_Waiting;
 2868|   688k|    bool    escaped = false;
 2869|   688k|    bool    gotLeadingSurrogate = false;
 2870|   688k|    bool    notDone = true;
 2871|  1.37M|    while (notDone)
  ------------------
  |  Branch (2871:12): [True: 688k, False: 688k]
  ------------------
 2872|   688k|    {
 2873|   688k|        try
 2874|   688k|        {
 2875|  2.02M|            while (true)
  ------------------
  |  Branch (2875:20): [Folded - Ignored]
  ------------------
 2876|  2.02M|            {
 2877|       |                //  Eat through as many plain content characters as possible without
 2878|       |                //  needing special handling.  Moving most content characters here,
 2879|       |                //  in this one call, rather than running the overall loop once
 2880|       |                //  per content character, is a speed optimization.
 2881|  2.02M|                if (curState == State_Waiting  &&  !gotLeadingSurrogate)
  ------------------
  |  Branch (2881:21): [True: 1.15M, False: 869k]
  |  Branch (2881:52): [True: 1.15M, False: 368]
  ------------------
 2882|  1.15M|                {
 2883|  1.15M|                     fReaderMgr.movePlainContentChars(toUse);
 2884|  1.15M|                }
 2885|       |
 2886|       |                // Try to get another char from the source
 2887|       |                //   The code from here on down covers all contengencies,
 2888|  2.02M|                if (!fReaderMgr.getNextCharIfNot(chOpenAngle, nextCh))
  ------------------
  |  Branch (2888:21): [True: 688k, False: 1.33M]
  ------------------
 2889|   688k|                {
 2890|       |                    // If we were waiting for a trailing surrogate, its an error
 2891|   688k|                    if (gotLeadingSurrogate)
  ------------------
  |  Branch (2891:25): [True: 0, False: 688k]
  ------------------
 2892|      0|                        emitError(XMLErrs::Expected2ndSurrogateChar);
 2893|       |
 2894|   688k|                    notDone = false;
 2895|   688k|                    break;
 2896|   688k|                }
 2897|       |
 2898|       |                //  Watch for a reference. Note that the escapement mechanism
 2899|       |                //  is ignored in this content.
 2900|  1.33M|                escaped = false;
 2901|  1.33M|                if (nextCh == chAmpersand)
  ------------------
  |  Branch (2901:21): [True: 9.49k, False: 1.32M]
  ------------------
 2902|  9.49k|                {
 2903|  9.49k|                    sendCharData(toUse);
 2904|       |
 2905|       |                    // Turn off the throwing at the end of entity during this
 2906|  9.49k|                    ThrowEOEJanitor jan(&fReaderMgr, false);
 2907|       |
 2908|  9.49k|                    if (scanEntityRef(false, nextCh, secondCh, escaped) != EntityExp_Returned)
  ------------------
  |  Branch (2908:25): [True: 7.28k, False: 2.20k]
  ------------------
 2909|  7.28k|                    {
 2910|  7.28k|                        gotLeadingSurrogate = false;
 2911|  7.28k|                        continue;
 2912|  7.28k|                    }
 2913|  2.20k|                    else
 2914|  2.20k|                    {
 2915|  2.20k|                        if (escaped && !fElemStack.isEmpty())
  ------------------
  |  Branch (2915:29): [True: 1.69k, False: 512]
  |  Branch (2915:40): [True: 1.69k, False: 0]
  ------------------
 2916|  1.69k|                            fElemStack.setReferenceEscaped();
 2917|  2.20k|                    }
 2918|  9.49k|                }
 2919|  1.32M|                else if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (2919:26): [True: 805, False: 1.32M]
  |  Branch (2919:48): [True: 368, False: 437]
  ------------------
 2920|    368|                {
 2921|       |                    // Deal with surrogate pairs
 2922|       |                    //  Its a leading surrogate. If we already got one, then
 2923|       |                    //  issue an error, else set leading flag to make sure that
 2924|       |                    //  we look for a trailing next time.
 2925|    368|                    if (gotLeadingSurrogate)
  ------------------
  |  Branch (2925:25): [True: 0, False: 368]
  ------------------
 2926|      0|                        emitError(XMLErrs::Expected2ndSurrogateChar);
 2927|    368|                    else
 2928|    368|                        gotLeadingSurrogate = true;
 2929|    368|                }
 2930|  1.32M|                else
 2931|  1.32M|                {
 2932|       |                    //  If its a trailing surrogate, make sure that we are
 2933|       |                    //  prepared for that. Else, its just a regular char so make
 2934|       |                    //  sure that we were not expected a trailing surrogate.
 2935|  1.32M|                    if ((nextCh >= 0xDC00) && (nextCh <= 0xDFFF))
  ------------------
  |  Branch (2935:25): [True: 437, False: 1.32M]
  |  Branch (2935:47): [True: 368, False: 69]
  ------------------
 2936|    368|                    {
 2937|       |                        // Its trailing, so make sure we were expecting it
 2938|    368|                        if (!gotLeadingSurrogate)
  ------------------
  |  Branch (2938:29): [True: 0, False: 368]
  ------------------
 2939|      0|                            emitError(XMLErrs::Unexpected2ndSurrogateChar);
 2940|    368|                    }
 2941|  1.32M|                    else
 2942|  1.32M|                    {
 2943|       |                        //  Its just a char, so make sure we were not expecting a
 2944|       |                        //  trailing surrogate.
 2945|  1.32M|                        if (gotLeadingSurrogate)
  ------------------
  |  Branch (2945:29): [True: 0, False: 1.32M]
  ------------------
 2946|      0|                            emitError(XMLErrs::Expected2ndSurrogateChar);
 2947|       |
 2948|       |                        // Make sure the returned char is a valid XML char
 2949|  1.32M|                        if (!fReaderMgr.getCurrentReader()->isXMLChar(nextCh))
  ------------------
  |  Branch (2949:29): [True: 26, False: 1.32M]
  ------------------
 2950|     26|                        {
 2951|     26|                            XMLCh tmpBuf[9];
 2952|     26|                            XMLString::binToText
 2953|     26|                            (
 2954|     26|                                nextCh
 2955|     26|                                , tmpBuf
 2956|     26|                                , 8
 2957|     26|                                , 16
 2958|     26|                                , fMemoryManager
 2959|     26|                            );
 2960|     26|                            emitError(XMLErrs::InvalidCharacter, tmpBuf);
 2961|     26|                        }
 2962|  1.32M|                    }
 2963|  1.32M|                    gotLeadingSurrogate = false;
 2964|  1.32M|                }
 2965|       |
 2966|       |                 // Keep the state machine up to date
 2967|  1.32M|                if (!escaped)
  ------------------
  |  Branch (2967:21): [True: 1.32M, False: 2.25k]
  ------------------
 2968|  1.32M|                {
 2969|  1.32M|                    if (nextCh == chCloseSquare)
  ------------------
  |  Branch (2969:25): [True: 869k, False: 457k]
  ------------------
 2970|   869k|                    {
 2971|   869k|                        if (curState == State_Waiting)
  ------------------
  |  Branch (2971:29): [True: 25.5k, False: 843k]
  ------------------
 2972|  25.5k|                            curState = State_GotOne;
 2973|   843k|                        else if (curState == State_GotOne)
  ------------------
  |  Branch (2973:34): [True: 498, False: 843k]
  ------------------
 2974|    498|                            curState = State_GotTwo;
 2975|   869k|                    }
 2976|   457k|                    else if (nextCh == chCloseAngle)
  ------------------
  |  Branch (2976:30): [True: 3.98k, False: 453k]
  ------------------
 2977|  3.98k|                    {
 2978|  3.98k|                        if (curState == State_GotTwo)
  ------------------
  |  Branch (2978:29): [True: 2, False: 3.97k]
  ------------------
 2979|      2|                            emitError(XMLErrs::BadSequenceInCharData);
 2980|  3.98k|                        curState = State_Waiting;
 2981|  3.98k|                    }
 2982|   453k|                    else
 2983|   453k|                    {
 2984|   453k|                        curState = State_Waiting;
 2985|   453k|                    }
 2986|  1.32M|                }
 2987|  2.25k|                else
 2988|  2.25k|                {
 2989|  2.25k|                    curState = State_Waiting;
 2990|  2.25k|                }
 2991|       |
 2992|       |                // Add this char to the buffer
 2993|  1.32M|                toUse.append(nextCh);
 2994|       |
 2995|  1.32M|                if (secondCh)
  ------------------
  |  Branch (2995:21): [True: 345, False: 1.32M]
  ------------------
 2996|    345|                {
 2997|    345|                    toUse.append(secondCh);
 2998|    345|                    secondCh=0;
 2999|    345|                }
 3000|  1.32M|            }
 3001|   688k|        }
 3002|   688k|        catch(const EndOfEntityException& toCatch)
 3003|   688k|        {
 3004|       |            //  Some entity ended, so we have to send any accumulated
 3005|       |            //  chars and send an end of entity event.
 3006|      0|            sendCharData(toUse);
 3007|      0|            gotLeadingSurrogate = false;
 3008|       |
 3009|      0|            if (fDocHandler)
  ------------------
  |  Branch (3009:17): [True: 0, False: 0]
  ------------------
 3010|      0|                fDocHandler->endEntityReference(toCatch.getEntity());
 3011|      0|        }
 3012|   688k|    }
 3013|       |
 3014|       |    // Check the validity constraints as per XML 1.0 Section 2.9
 3015|   688k|    if (fValidate && fStandalone)
  ------------------
  |  Branch (3015:9): [True: 688k, False: 0]
  |  Branch (3015:22): [True: 368k, False: 319k]
  ------------------
 3016|   368k|    {
 3017|       |        // See if the text contains whitespace
 3018|       |        // Get the raw data we need for the callback
 3019|   368k|        const XMLCh* rawBuf = toUse.getRawBuffer();
 3020|   368k|        const XMLSize_t len = toUse.getLen();
 3021|   368k|        const bool isSpaces = fReaderMgr.getCurrentReader()->containsWhiteSpace(rawBuf, len);
 3022|       |
 3023|   368k|        if (isSpaces)
  ------------------
  |  Branch (3023:13): [True: 309k, False: 59.3k]
  ------------------
 3024|   309k|        {
 3025|       |            // And see if the current element is a 'Children' style content model
 3026|   309k|            const ElemStack::StackElem* topElem = fElemStack.topElement();
 3027|       |
 3028|   309k|            if (topElem->fThisElement->isExternal()) {
  ------------------
  |  Branch (3028:17): [True: 127k, False: 181k]
  ------------------
 3029|       |
 3030|       |                // Get the character data opts for the current element
 3031|   127k|                XMLElementDecl::CharDataOpts charOpts = XMLElementDecl::AllCharData;
 3032|   127k|                if(fGrammar->getGrammarType() == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (3032:20): [True: 0, False: 127k]
  ------------------
 3033|      0|                {
 3034|       |                    // And see if the current element is a 'Children' style content model
 3035|      0|                    ComplexTypeInfo *currType = ((SchemaValidator*)fValidator)->getCurrentTypeInfo();
 3036|      0|                    if(currType)
  ------------------
  |  Branch (3036:24): [True: 0, False: 0]
  ------------------
 3037|      0|                    {
 3038|      0|                        SchemaElementDecl::ModelTypes modelType = (SchemaElementDecl::ModelTypes) currType->getContentType();
 3039|      0|                        if(modelType == SchemaElementDecl::Children ||
  ------------------
  |  Branch (3039:28): [True: 0, False: 0]
  ------------------
 3040|      0|                           modelType == SchemaElementDecl::ElementOnlyEmpty)
  ------------------
  |  Branch (3040:28): [True: 0, False: 0]
  ------------------
 3041|      0|                            charOpts = XMLElementDecl::SpacesOk;
 3042|      0|                        else if(modelType == SchemaElementDecl::Empty)
  ------------------
  |  Branch (3042:33): [True: 0, False: 0]
  ------------------
 3043|      0|                            charOpts = XMLElementDecl::NoCharData;
 3044|      0|                    }
 3045|      0|                } else // DTD grammar
 3046|   127k|                    charOpts = topElem->fThisElement->getCharDataOpts();
 3047|       |
 3048|   127k|                if (charOpts == XMLElementDecl::SpacesOk)  // => Element Content
  ------------------
  |  Branch (3048:21): [True: 0, False: 127k]
  ------------------
 3049|      0|                {
 3050|       |                    // Error - standalone should have a value of "no" as whitespace detected in an
 3051|       |                    // element type with element content whose element declaration was external
 3052|       |                    //
 3053|      0|                    fValidator->emitError(XMLValid::NoWSForStandalone);
 3054|      0|                    if(fGrammarType == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (3054:24): [True: 0, False: 0]
  ------------------
 3055|      0|                    {
 3056|      0|                        if (getPSVIHandler())
  ------------------
  |  Branch (3056:29): [True: 0, False: 0]
  ------------------
 3057|      0|                        {
 3058|       |                            // REVISIT:
 3059|       |                            // PSVIElement->setValidity(PSVIItem::VALIDITY_INVALID);
 3060|      0|                        }
 3061|      0|                    }
 3062|      0|                }
 3063|   127k|            }
 3064|   309k|        }
 3065|   368k|    }
 3066|       |    // Send any char data that we accumulated into the buffer
 3067|   688k|    sendCharData(toUse);
 3068|   688k|}
_ZN11xercesc_3_212IGXMLScanner13scanEntityRefEbRDsS1_Rb:
 3087|  22.6k|{
 3088|       |    // Assume no escape
 3089|  22.6k|    secondCh = 0;
 3090|  22.6k|    escaped = false;
 3091|       |
 3092|       |    // We have to insure that its all in one entity
 3093|  22.6k|    const XMLSize_t curReader = fReaderMgr.getCurrentReaderNum();
 3094|       |
 3095|       |    //  If the next char is a pound, then its a character reference and we
 3096|       |    //  need to expand it always.
 3097|  22.6k|    if (fReaderMgr.skippedChar(chPound))
  ------------------
  |  Branch (3097:9): [True: 9.74k, False: 12.8k]
  ------------------
 3098|  9.74k|    {
 3099|       |        //  Its a character reference, so scan it and get back the numeric
 3100|       |        //  value it represents.
 3101|  9.74k|        if (!scanCharRef(firstCh, secondCh))
  ------------------
  |  Branch (3101:13): [True: 0, False: 9.74k]
  ------------------
 3102|      0|            return EntityExp_Failed;
 3103|       |
 3104|  9.74k|        escaped = true;
 3105|       |
 3106|  9.74k|        if (curReader != fReaderMgr.getCurrentReaderNum())
  ------------------
  |  Branch (3106:13): [True: 0, False: 9.74k]
  ------------------
 3107|      0|            emitError(XMLErrs::PartialMarkupInEntity);
 3108|       |
 3109|  9.74k|        return EntityExp_Returned;
 3110|  9.74k|    }
 3111|       |
 3112|       |    // Expand it since its a normal entity ref
 3113|  12.8k|    XMLBufBid bbName(&fBufMgr);
 3114|  12.8k|    int  colonPosition;
 3115|  12.8k|    bool validName = fDoNamespaces ? fReaderMgr.getQName(bbName.getBuffer(), &colonPosition) :
  ------------------
  |  Branch (3115:22): [True: 0, False: 12.8k]
  ------------------
 3116|  12.8k|                                     fReaderMgr.getName(bbName.getBuffer());
 3117|  12.8k|    if (!validName)
  ------------------
  |  Branch (3117:9): [True: 31, False: 12.8k]
  ------------------
 3118|     31|    {
 3119|     31|        if (bbName.isEmpty())
  ------------------
  |  Branch (3119:13): [True: 31, False: 0]
  ------------------
 3120|     31|            emitError(XMLErrs::ExpectedEntityRefName);
 3121|      0|        else
 3122|      0|            emitError(XMLErrs::InvalidEntityRefName, bbName.getRawBuffer());
 3123|     31|        return EntityExp_Failed;
 3124|     31|    }
 3125|       |
 3126|       |    //  Next char must be a semi-colon. But if its not, just emit
 3127|       |    //  an error and try to continue.
 3128|  12.8k|    if (!fReaderMgr.skippedChar(chSemiColon))
  ------------------
  |  Branch (3128:9): [True: 4, False: 12.8k]
  ------------------
 3129|      4|        emitError(XMLErrs::UnterminatedEntityRef, bbName.getRawBuffer());
 3130|       |
 3131|       |    // Make sure we ended up on the same entity reader as the & char
 3132|  12.8k|    if (curReader != fReaderMgr.getCurrentReaderNum())
  ------------------
  |  Branch (3132:9): [True: 0, False: 12.8k]
  ------------------
 3133|      0|        emitError(XMLErrs::PartialMarkupInEntity);
 3134|       |
 3135|       |    // Look up the name in the general entity pool
 3136|  12.8k|    XMLEntityDecl* decl = fDTDGrammar->getEntityDecl(bbName.getRawBuffer());
 3137|       |
 3138|       |    // If it does not exist, then obviously an error
 3139|  12.8k|    if (!decl)
  ------------------
  |  Branch (3139:9): [True: 2.20k, False: 10.6k]
  ------------------
 3140|  2.20k|    {
 3141|       |        // XML 1.0 Section 4.1
 3142|       |        // Well-formedness Constraint for entity not found:
 3143|       |        //   In a document without any DTD, a document with only an internal DTD subset which contains no parameter entity references,
 3144|       |        //      or a document with "standalone='yes'", for an entity reference that does not occur within the external subset
 3145|       |        //      or a parameter entity
 3146|       |        //
 3147|       |        // Else it's Validity Constraint
 3148|  2.20k|        if (fStandalone || fHasNoDTD)
  ------------------
  |  Branch (3148:13): [True: 15, False: 2.19k]
  |  Branch (3148:28): [True: 1, False: 2.19k]
  ------------------
 3149|     16|            emitError(XMLErrs::EntityNotFound, bbName.getRawBuffer());
 3150|  2.19k|        else {
 3151|  2.19k|            if (fValidate)
  ------------------
  |  Branch (3151:17): [True: 2.19k, False: 0]
  ------------------
 3152|  2.19k|                fValidator->emitError(XMLValid::VC_EntityNotFound, bbName.getRawBuffer());
 3153|  2.19k|        }
 3154|       |
 3155|  2.20k|        return EntityExp_Failed;
 3156|  2.20k|    }
 3157|       |
 3158|       |    // XML 1.0 Section 4.1
 3159|       |    //  If we are a standalone document, then it has to have been declared
 3160|       |    //  in the internal subset.
 3161|  10.6k|    if (fStandalone && !decl->getDeclaredInIntSubset())
  ------------------
  |  Branch (3161:9): [True: 8.35k, False: 2.29k]
  |  Branch (3161:24): [True: 0, False: 8.35k]
  ------------------
 3162|      0|        emitError(XMLErrs::IllegalRefInStandalone, bbName.getRawBuffer());
 3163|       |
 3164|  10.6k|    if (decl->isExternal())
  ------------------
  |  Branch (3164:9): [True: 393, False: 10.2k]
  ------------------
 3165|    393|    {
 3166|       |        // If its unparsed, then its not valid here
 3167|    393|        if (decl->isUnparsed())
  ------------------
  |  Branch (3167:13): [True: 1, False: 392]
  ------------------
 3168|      1|        {
 3169|      1|            emitError(XMLErrs::NoUnparsedEntityRefs, bbName.getRawBuffer());
 3170|      1|            return EntityExp_Failed;
 3171|      1|        }
 3172|       |
 3173|       |        // If we are in an attribute value, then not valid but keep going
 3174|    392|        if (inAttVal)
  ------------------
  |  Branch (3174:13): [True: 1, False: 391]
  ------------------
 3175|      1|            emitError(XMLErrs::NoExtRefsInAttValue);
 3176|       |
 3177|       |        // And now create a reader to read this entity
 3178|    392|        InputSource* srcUsed;
 3179|    392|        XMLReader* reader = fReaderMgr.createReader
 3180|    392|        (
 3181|    392|            decl->getBaseURI()
 3182|    392|            , decl->getSystemId()
 3183|    392|            , decl->getPublicId()
 3184|    392|            , false
 3185|    392|            , XMLReader::RefFrom_NonLiteral
 3186|    392|            , XMLReader::Type_General
 3187|    392|            , XMLReader::Source_External
 3188|    392|            , srcUsed
 3189|    392|            , fCalculateSrcOfs
 3190|    392|            , fLowWaterMark
 3191|    392|            , fDisableDefaultEntityResolution
 3192|    392|        );
 3193|       |
 3194|       |        // Put a janitor on the source so it gets cleaned up on exit
 3195|    392|        Janitor<InputSource> janSrc(srcUsed);
 3196|       |
 3197|       |        //  If the creation failed, and its not because the source was empty,
 3198|       |        //  then emit an error and return.
 3199|    392|        if (!reader)
  ------------------
  |  Branch (3199:13): [True: 92, False: 300]
  ------------------
 3200|     92|            ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Gen_CouldNotOpenExtEntity, srcUsed ? srcUsed->getSystemId() : decl->getSystemId(), fMemoryManager);
  ------------------
  |  |  266|    184|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |  |  Branch (266:87): [True: 92, False: 0]
  |  |  ------------------
  ------------------
 3201|       |
 3202|       |        //  Push the reader. If its a recursive expansion, then emit an error
 3203|       |        //  and return an failure.
 3204|    300|        if (!fReaderMgr.pushReader(reader, decl))
  ------------------
  |  Branch (3204:13): [True: 0, False: 300]
  ------------------
 3205|      0|        {
 3206|      0|            emitError(XMLErrs::RecursiveEntity, decl->getName());
 3207|      0|            return EntityExp_Failed;
 3208|      0|        }
 3209|       |
 3210|       |        // here's where we need to check if there's a SecurityManager,
 3211|       |        // how many entity references we've had
 3212|    300|        if(fSecurityManager != 0 && ++fEntityExpansionCount > fEntityExpansionLimit) {
  ------------------
  |  Branch (3212:12): [True: 0, False: 300]
  |  Branch (3212:37): [True: 0, False: 0]
  ------------------
 3213|      0|            XMLCh expLimStr[32];
 3214|      0|            XMLString::sizeToText(fEntityExpansionLimit, expLimStr, 31, 10, fMemoryManager);
 3215|      0|            emitError
 3216|      0|            (
 3217|      0|                XMLErrs::EntityExpansionLimitExceeded
 3218|      0|                , expLimStr
 3219|      0|            );
 3220|       |            // there seems nothing  better to be done than to reset the entity expansion counter
 3221|      0|            fEntityExpansionCount = 0;
 3222|      0|        }
 3223|       |
 3224|       |        //  Do a start entity reference event.
 3225|       |        //
 3226|       |        //  <TBD> For now, we supress them in att values. Later, when
 3227|       |        //  the stuff is in place to correctly allow DOM to handle them
 3228|       |        //  we'll turn this back on.
 3229|    300|        if (fDocHandler && !inAttVal)
  ------------------
  |  Branch (3229:13): [True: 0, False: 300]
  |  Branch (3229:28): [True: 0, False: 0]
  ------------------
 3230|      0|            fDocHandler->startEntityReference(*decl);
 3231|       |
 3232|       |        // If it starts with the XML string, then parse a text decl
 3233|    300|        if (checkXMLDecl(true))
  ------------------
  |  Branch (3233:13): [True: 0, False: 300]
  ------------------
 3234|      0|            scanXMLDecl(Decl_Text);
 3235|    300|    }
 3236|  10.2k|    else
 3237|  10.2k|    {
 3238|       |        //  If its one of the special char references, then we can return
 3239|       |        //  it as a character, and its considered escaped.
 3240|  10.2k|        if (decl->getIsSpecialChar())
  ------------------
  |  Branch (3240:13): [True: 281, False: 9.97k]
  ------------------
 3241|    281|        {
 3242|    281|            firstCh = decl->getValue()[0];
 3243|    281|            escaped = true;
 3244|    281|            return EntityExp_Returned;
 3245|    281|        }
 3246|       |
 3247|       |        //  Create a reader over a memory stream over the entity value
 3248|       |        //  We force it to assume UTF-16 by passing in an encoding
 3249|       |        //  string. This way it won't both trying to predecode the
 3250|       |        //  first line, looking for an XML/TextDecl.
 3251|  9.97k|        XMLReader* valueReader = fReaderMgr.createIntEntReader
 3252|  9.97k|        (
 3253|  9.97k|            decl->getName()
 3254|  9.97k|            , XMLReader::RefFrom_NonLiteral
 3255|  9.97k|            , XMLReader::Type_General
 3256|  9.97k|            , decl->getValue()
 3257|  9.97k|            , decl->getValueLen()
 3258|  9.97k|            , false
 3259|  9.97k|        );
 3260|       |
 3261|       |        //  Try to push the entity reader onto the reader manager stack,
 3262|       |        //  where it will become the subsequent input. If it fails, that
 3263|       |        //  means the entity is recursive, so issue an error. The reader
 3264|       |        //  will have just been discarded, but we just keep going.
 3265|  9.97k|        if (!fReaderMgr.pushReader(valueReader, decl))
  ------------------
  |  Branch (3265:13): [True: 12, False: 9.96k]
  ------------------
 3266|     12|            emitError(XMLErrs::RecursiveEntity, decl->getName());
 3267|       |
 3268|       |        // here's where we need to check if there's a SecurityManager,
 3269|       |        // how many entity references we've had
 3270|  9.97k|        if(fSecurityManager != 0 && ++fEntityExpansionCount > fEntityExpansionLimit) {
  ------------------
  |  Branch (3270:12): [True: 0, False: 9.97k]
  |  Branch (3270:37): [True: 0, False: 0]
  ------------------
 3271|      0|            XMLCh expLimStr[32];
 3272|      0|            XMLString::sizeToText(fEntityExpansionLimit, expLimStr, 31, 10, fMemoryManager);
 3273|      0|            emitError
 3274|      0|            (
 3275|      0|                XMLErrs::EntityExpansionLimitExceeded
 3276|      0|                , expLimStr
 3277|      0|            );
 3278|      0|        }
 3279|       |
 3280|       |        //  Do a start entity reference event.
 3281|       |        //
 3282|       |        //  <TBD> For now, we supress them in att values. Later, when
 3283|       |        //  the stuff is in place to correctly allow DOM to handle them
 3284|       |        //  we'll turn this back on.
 3285|  9.97k|        if (fDocHandler && !inAttVal)
  ------------------
  |  Branch (3285:13): [True: 0, False: 9.97k]
  |  Branch (3285:28): [True: 0, False: 0]
  ------------------
 3286|      0|            fDocHandler->startEntityReference(*decl);
 3287|       |
 3288|       |        // If it starts with the XML string, then it's an error
 3289|  9.97k|        if (checkXMLDecl(true)) {
  ------------------
  |  Branch (3289:13): [True: 1, False: 9.97k]
  ------------------
 3290|      1|            emitError(XMLErrs::TextDeclNotLegalHere);
 3291|      1|            fReaderMgr.skipPastChar(chCloseAngle);
 3292|      1|        }
 3293|  9.97k|    }
 3294|  10.2k|    return EntityExp_Pushed;
 3295|  10.6k|}
_ZN11xercesc_3_212IGXMLScanner13switchGrammarEPKDs:
 3299|  8.31k|{
 3300|  8.31k|    Grammar* tempGrammar = fGrammarResolver->getGrammar(newGrammarNameSpace);
 3301|       |
 3302|  8.31k|    if (!tempGrammar && !fSkipDTDValidation) {
  ------------------
  |  Branch (3302:9): [True: 0, False: 8.31k]
  |  Branch (3302:25): [True: 0, False: 0]
  ------------------
 3303|       |        // This is a case where namespaces is on with a DTD grammar.
 3304|      0|        tempGrammar = fDTDGrammar;
 3305|      0|    }
 3306|  8.31k|    if (!tempGrammar) {
  ------------------
  |  Branch (3306:9): [True: 0, False: 8.31k]
  ------------------
 3307|      0|        return false;
 3308|      0|    }
 3309|  8.31k|    else {
 3310|       |
 3311|  8.31k|        Grammar::GrammarType tempGrammarType = tempGrammar->getGrammarType();
 3312|  8.31k|        if (tempGrammarType == Grammar::SchemaGrammarType && !fValidator->handlesSchema()) {
  ------------------
  |  Branch (3312:13): [True: 0, False: 8.31k]
  |  Branch (3312:62): [True: 0, False: 0]
  ------------------
 3313|      0|            if (fValidatorFromUser)
  ------------------
  |  Branch (3313:17): [True: 0, False: 0]
  ------------------
 3314|      0|                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Gen_NoSchemaValidator, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 3315|      0|            else {
 3316|      0|                fValidator = fSchemaValidator;
 3317|      0|            }
 3318|      0|        }
 3319|  8.31k|        else if (tempGrammarType == Grammar::DTDGrammarType) {
  ------------------
  |  Branch (3319:18): [True: 8.31k, False: 0]
  ------------------
 3320|  8.31k|            if (fSkipDTDValidation) {
  ------------------
  |  Branch (3320:17): [True: 0, False: 8.31k]
  ------------------
 3321|      0|                return false;
 3322|      0|            }
 3323|       |
 3324|  8.31k|            if (!fValidator->handlesDTD()) {
  ------------------
  |  Branch (3324:17): [True: 0, False: 8.31k]
  ------------------
 3325|      0|                if (fValidatorFromUser)
  ------------------
  |  Branch (3325:21): [True: 0, False: 0]
  ------------------
 3326|      0|                    ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Gen_NoDTDValidator, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 3327|      0|                else {
 3328|      0|                    fValidator = fDTDValidator;
 3329|      0|                }
 3330|      0|            }
 3331|  8.31k|        }
 3332|       |
 3333|  8.31k|        fGrammarType = tempGrammarType;
 3334|  8.31k|        fGrammar = tempGrammar;
 3335|  8.31k|        fValidator->setGrammar(fGrammar);
 3336|  8.31k|        return true;
 3337|  8.31k|    }
 3338|  8.31k|}

_ZN11xercesc_3_217MemoryManagerImpl25getExceptionMemoryManagerEv:
   32|  2.95k|{
   33|  2.95k|    return this;
   34|  2.95k|}
_ZN11xercesc_3_217MemoryManagerImpl8allocateEm:
   37|  60.5M|{
   38|  60.5M|    void* memptr;
   39|  60.5M|    try {
   40|  60.5M|        memptr = ::operator new(size);
   41|  60.5M|    }
   42|  60.5M|    catch(...) {
   43|      0|        throw OutOfMemoryException();
   44|      0|    }
   45|  60.5M|    if(memptr==NULL && size!=0)
  ------------------
  |  Branch (45:8): [True: 0, False: 60.5M]
  |  Branch (45:24): [True: 0, False: 0]
  ------------------
   46|      0|        throw OutOfMemoryException();
   47|  60.5M|    return memptr;
   48|  60.5M|}
_ZN11xercesc_3_217MemoryManagerImpl10deallocateEPv:
   51|  67.3M|{
   52|  67.3M|    if (p)
  ------------------
  |  Branch (52:9): [True: 60.5M, False: 6.78M]
  ------------------
   53|  60.5M|        ::operator delete(p);
   54|  67.3M|}

_ZN11xercesc_3_217MemoryManagerImplC2Ev:
   49|      1|    {
   50|      1|    }

_ZN11xercesc_3_29ReaderMgrC2EPNS_13MemoryManagerE:
   63|  8.51k|{
   64|  8.51k|}
_ZN11xercesc_3_29ReaderMgrD2Ev:
   67|  8.51k|{
   68|       |    //
   69|       |    //  Clean up the reader and entity stacks. Note that we don't own the
   70|       |    //  entities, so we don't delete the current entity (and the entity stack
   71|       |    //  does not own its elements either, so deleting it will not delete the
   72|       |    //  entities it still references!)
   73|       |    //
   74|  8.51k|    delete fCurReader;
   75|  8.51k|    delete fReaderStack;
   76|  8.51k|    delete fEntityStack;
   77|  8.51k|}
_ZN11xercesc_3_29ReaderMgr11getNextCharEv:
   93|   129M|{
   94|   129M|    XMLCh chRet;
   95|   129M|    if (fCurReader->getNextChar(chRet))
  ------------------
  |  Branch (95:9): [True: 129M, False: 10.1k]
  ------------------
   96|   129M|        return chRet;
   97|       |
   98|       |    //
   99|       |    //  Didn't get anything back so this reader is hosed. So lets move to
  100|       |    //  the next reader on the stack. If this fails, it will be because
  101|       |    //  its the end of the original file, and we just return zero.
  102|       |    //
  103|       |    //  If its the end of an entity and fThrowEOE is set, it will throw out
  104|       |    //  of here. Otherwise, it will take us down to the next reader and
  105|       |    //  we'll have more chars.
  106|       |    //
  107|  10.1k|    if (!popReader())
  ------------------
  |  Branch (107:9): [True: 457, False: 9.68k]
  ------------------
  108|    457|        return XMLCh(0);
  109|       |
  110|       |    // Else try again and return the new character
  111|  9.68k|    fCurReader->getNextChar(chRet);
  112|  9.68k|    return chRet;
  113|  10.1k|}
_ZN11xercesc_3_29ReaderMgr15getUpToCharOrWSERNS_9XMLBufferEDs:
  136|  24.6k|{
  137|       |    // Reset the target buffer before we start
  138|  24.6k|    toFill.reset();
  139|       |
  140|       |    //
  141|       |    //  Ok, enter a loop where we ask the current reader to get chars until
  142|       |    //  it meets the criteria. It returns false if it came back due to eating
  143|       |    //  up all of its data. Else it returned because something matched, and
  144|       |    //  we are done.
  145|       |    //
  146|  24.6k|    while (!fCurReader->getUpToCharOrWS(toFill, toCheck))
  ------------------
  |  Branch (146:12): [True: 0, False: 24.6k]
  ------------------
  147|      0|    {
  148|       |        // We ate that one up, lets try to pop another. If not, break out
  149|      0|        if (!popReader())
  ------------------
  |  Branch (149:13): [True: 0, False: 0]
  ------------------
  150|      0|            break;
  151|      0|    }
  152|  24.6k|}
_ZN11xercesc_3_29ReaderMgr12peekNextCharEv:
  156|  6.78M|{
  157|  6.78M|    XMLCh chRet;
  158|  6.78M|    if (fCurReader->peekNextChar(chRet))
  ------------------
  |  Branch (158:9): [True: 6.77M, False: 7.25k]
  ------------------
  159|  6.77M|        return chRet;
  160|       |
  161|       |    //
  162|       |    //  Didn't get anything back so this reader is hosed. So lets move to
  163|       |    //  the next reader on the stack. If this fails, it will be because
  164|       |    //  its the end of the original file, and we just return zero.
  165|       |    //
  166|  7.25k|    if (!popReader())
  ------------------
  |  Branch (166:9): [True: 1.72k, False: 5.53k]
  ------------------
  167|  1.72k|        return XMLCh(0);
  168|       |
  169|       |    // Else peek again and return the character
  170|  5.53k|    fCurReader->peekNextChar(chRet);
  171|  5.53k|    return chRet;
  172|  7.25k|}
_ZN11xercesc_3_29ReaderMgr11skippedCharEDs:
  176|  7.22M|{
  177|  7.22M|    while (true)
  ------------------
  |  Branch (177:12): [Folded - Ignored]
  ------------------
  178|  7.22M|    {
  179|       |        // If we get it, then just return true now
  180|  7.22M|        if (fCurReader->skippedChar(toCheck))
  ------------------
  |  Branch (180:13): [True: 2.43M, False: 4.79M]
  ------------------
  181|  2.43M|            return true;
  182|       |
  183|       |        //
  184|       |        //  Check to see if we hit end of input on this reader. If so, then
  185|       |        //  lets pop and try again. Else, we failed. If we cannot pop another
  186|       |        //  then we failed.
  187|       |        //
  188|  4.79M|        if (!fCurReader->getNoMoreFlag())
  ------------------
  |  Branch (188:13): [True: 4.79M, False: 24]
  ------------------
  189|  4.79M|            break;
  190|       |
  191|     24|        if (!popReader())
  ------------------
  |  Branch (191:13): [True: 9, False: 15]
  ------------------
  192|      9|            break;
  193|     24|    }
  194|  4.79M|    return false;
  195|  7.22M|}
_ZN11xercesc_3_29ReaderMgr12skippedSpaceEv:
  199|  3.24M|{
  200|  3.24M|    while (true)
  ------------------
  |  Branch (200:12): [Folded - Ignored]
  ------------------
  201|  3.24M|    {
  202|       |        // If we get it, then just return true now
  203|  3.24M|        if (fCurReader->skippedSpace())
  ------------------
  |  Branch (203:13): [True: 114k, False: 3.13M]
  ------------------
  204|   114k|            return true;
  205|       |
  206|       |        //
  207|       |        //  Check to see if we hit end of input on this reader. If so, then
  208|       |        //  lets pop and try again. Else, we failed. If we cannot pop another
  209|       |        //  then we failed.
  210|       |        //
  211|  3.13M|        if (!fCurReader->getNoMoreFlag())
  ------------------
  |  Branch (211:13): [True: 3.13M, False: 20]
  ------------------
  212|  3.13M|            break;
  213|       |
  214|     20|        if (!popReader())
  ------------------
  |  Branch (214:13): [True: 6, False: 14]
  ------------------
  215|      6|            break;
  216|     20|    }
  217|  3.13M|    return false;
  218|  3.24M|}
_ZN11xercesc_3_29ReaderMgr11skipIfQuoteERDs:
  222|   519k|{
  223|   519k|    while (true)
  ------------------
  |  Branch (223:12): [Folded - Ignored]
  ------------------
  224|   519k|    {
  225|       |        // If we get it, then just return true now
  226|   519k|        if (fCurReader->skipIfQuote(chGotten))
  ------------------
  |  Branch (226:13): [True: 519k, False: 94]
  ------------------
  227|   519k|            return true;
  228|       |
  229|       |        //
  230|       |        //  Check to see if we hit end of input on this reader. If so, then
  231|       |        //  lets pop and try again. Else, we failed. If we cannot pop another
  232|       |        //  then we failed.
  233|       |        //
  234|     94|        if (!fCurReader->getNoMoreFlag())
  ------------------
  |  Branch (234:13): [True: 92, False: 2]
  ------------------
  235|     92|            break;
  236|       |
  237|      2|        if (!popReader())
  ------------------
  |  Branch (237:13): [True: 2, False: 0]
  ------------------
  238|      2|            break;
  239|      2|    }
  240|     94|    return false;
  241|   519k|}
_ZN11xercesc_3_29ReaderMgr14skipPastSpacesERbb:
  244|   473k|{
  245|       |    // we rely on the fact that fCurReader->skipSpaces will NOT reset the flag to false, but only
  246|       |    // set it to true if a space is found
  247|   473k|    skippedSomething = false;
  248|       |    //
  249|       |    //  Skip all the spaces in the current reader. If it returned because
  250|       |    //  it hit a non-space, break out. Else we have to pop another entity
  251|       |    //  and keep going.
  252|       |    //
  253|   473k|    while (!fCurReader->skipSpaces(skippedSomething, inDecl))
  ------------------
  |  Branch (253:12): [True: 3, False: 473k]
  ------------------
  254|      3|    {
  255|       |        // Try to pop another entity. If we can't then we are done
  256|      3|        if (!popReader())
  ------------------
  |  Branch (256:13): [True: 2, False: 1]
  ------------------
  257|      2|            break;
  258|      3|    }
  259|   473k|}
_ZN11xercesc_3_29ReaderMgr14skipPastSpacesEv:
  262|  2.28M|{
  263|       |    // we are not using it, so we don't care to initialize it
  264|  2.28M|    bool tmpFlag;
  265|       |    //
  266|       |    //  Skip all the spaces in the current reader. If it returned because
  267|       |    //  it hit a non-space, break out. Else we have to pop another entity
  268|       |    //  and keep going.
  269|       |    //
  270|  2.28M|    while (!fCurReader->skipSpaces(tmpFlag, false))
  ------------------
  |  Branch (270:12): [True: 1.23k, False: 2.28M]
  ------------------
  271|  1.23k|    {
  272|       |        // Try to pop another entity. If we can't then we are done
  273|  1.23k|        if (!popReader())
  ------------------
  |  Branch (273:13): [True: 479, False: 752]
  ------------------
  274|    479|            break;
  275|  1.23k|    }
  276|  2.28M|}
_ZNK11xercesc_3_29ReaderMgr5atEOFEv:
  336|  5.31k|{
  337|  5.31k|    return fReaderStack->empty() && fCurReader->getNoMoreFlag();
  ------------------
  |  Branch (337:12): [True: 5.31k, False: 0]
  |  Branch (337:37): [True: 0, False: 5.31k]
  ------------------
  338|  5.31k|}
_ZN11xercesc_3_29ReaderMgr12createReaderERKNS_11InputSourceEbNS_9XMLReader7RefFromENS4_5TypesENS4_7SourcesEbm:
  374|  10.9k|{
  375|       |    //
  376|       |    //  Ask the input source to create us an input stream. The particular
  377|       |    //  type of input source will know what kind to create.
  378|       |    //
  379|  10.9k|    BinInputStream* newStream = src.makeStream();
  380|  10.9k|    if (!newStream)
  ------------------
  |  Branch (380:9): [True: 2.09k, False: 8.80k]
  ------------------
  381|  2.09k|        return 0;
  382|       |
  383|  8.80k|    Janitor<BinInputStream>   streamJanitor(newStream);
  384|       |
  385|       |    //
  386|       |    //  Create a new reader and return it. If the source has an encoding that
  387|       |    //  it wants to force, then we call the constructor that does that.
  388|       |    //  Otherwise, we just call the one that provides the provisional encoding
  389|       |    //  to be possibly updated later by the encoding="" setting.
  390|       |    //
  391|  8.80k|    XMLReader* retVal = 0;
  392|       |
  393|       |    // XMLReader ctor invokes refreshRawBuffer() which calls
  394|       |    // newStream->readBytes().
  395|       |    // This readBytes() may throw exception, which neither
  396|       |    // refresRawBuffer(), nor XMLReader ctor catches.
  397|       |    // We need to handle this exception to avoid leak on newStream.
  398|       |
  399|  8.80k|    try {
  400|  8.80k|		const XMLCh* encoding = src.getEncoding();
  401|  8.80k|		if(encoding == 0)
  ------------------
  |  Branch (401:6): [True: 8.52k, False: 282]
  ------------------
  402|  8.52k|			encoding = newStream->getEncoding();
  403|  8.80k|        if (encoding)
  ------------------
  |  Branch (403:13): [True: 0, False: 8.80k]
  ------------------
  404|      0|        {
  405|      0|            retVal = new (fMemoryManager) XMLReader
  406|      0|                (
  407|      0|                src.getPublicId()
  408|      0|                , src.getSystemId()
  409|      0|                , newStream
  410|      0|                , encoding
  411|      0|                , refFrom
  412|      0|                , type
  413|      0|                , source
  414|      0|                , false
  415|      0|                , calcSrcOfs
  416|      0|                , lowWaterMark
  417|      0|                , fXMLVersion
  418|      0|                , fMemoryManager
  419|      0|                );
  420|      0|        }
  421|  8.80k|        else
  422|  8.80k|        {
  423|  8.80k|            retVal = new (fMemoryManager) XMLReader
  424|  8.80k|                (
  425|  8.80k|                src.getPublicId()
  426|  8.80k|                , src.getSystemId()
  427|  8.80k|                , newStream
  428|  8.80k|                , refFrom
  429|  8.80k|                , type
  430|  8.80k|                , source
  431|  8.80k|                , false
  432|  8.80k|                , calcSrcOfs
  433|  8.80k|                , lowWaterMark
  434|  8.80k|                , fXMLVersion
  435|  8.80k|                , fMemoryManager
  436|  8.80k|                );
  437|  8.80k|        }
  438|  8.80k|    }
  439|  8.80k|    catch(const OutOfMemoryException&)
  440|  8.80k|    {
  441|      0|        streamJanitor.release();
  442|       |
  443|      0|        throw;
  444|      0|    }
  445|       |
  446|  8.51k|    assert(retVal);
  447|       |
  448|      0|    streamJanitor.release();
  449|       |
  450|       |    // Set the next available reader number on this reader
  451|  8.51k|    retVal->setReaderNum(fNextReaderNum++);
  452|  8.51k|    return retVal;
  453|  8.80k|}
_ZN11xercesc_3_29ReaderMgr12createReaderEPKDsS2_bNS_9XMLReader7RefFromENS3_5TypesENS3_7SourcesERPNS_11InputSourceEbmb:
  466|  2.00k|{
  467|       |    //Normalize sysId
  468|  2.00k|    XMLBuffer normalizedSysId(1023, fMemoryManager);
  469|  2.00k|    if(sysId)
  ------------------
  |  Branch (469:8): [True: 2.00k, False: 0]
  ------------------
  470|  2.00k|        XMLString::removeChar(sysId, 0xFFFF, normalizedSysId);
  471|  2.00k|    const XMLCh* normalizedURI = normalizedSysId.getRawBuffer();
  472|       |
  473|       |    // Create a buffer for expanding the system id
  474|  2.00k|    XMLBuffer expSysId(1023, fMemoryManager);
  475|       |
  476|       |    //
  477|       |    //  Allow the entity handler to expand the system id if they choose
  478|       |    //  to do so.
  479|       |    //
  480|  2.00k|    if (fEntityHandler)
  ------------------
  |  Branch (480:9): [True: 0, False: 2.00k]
  ------------------
  481|      0|    {
  482|      0|        if (!fEntityHandler->expandSystemId(normalizedURI, expSysId))
  ------------------
  |  Branch (482:13): [True: 0, False: 0]
  ------------------
  483|      0|            expSysId.set(normalizedURI);
  484|      0|    }
  485|  2.00k|     else
  486|  2.00k|    {
  487|  2.00k|        expSysId.set(normalizedURI);
  488|  2.00k|    }
  489|       |
  490|       |    // Call the entity resolver interface to get an input source
  491|  2.00k|    srcToFill = 0;
  492|  2.00k|    if (fEntityHandler)
  ------------------
  |  Branch (492:9): [True: 0, False: 2.00k]
  ------------------
  493|      0|    {
  494|      0|        LastExtEntityInfo lastInfo;
  495|      0|        getLastExtEntityInfo(lastInfo);
  496|      0|        XMLResourceIdentifier resourceIdentifier(XMLResourceIdentifier::ExternalEntity,
  497|      0|                            expSysId.getRawBuffer(), XMLUni::fgZeroLenString, pubId, lastInfo.systemId,
  498|      0|                            this);
  499|      0|        srcToFill = fEntityHandler->resolveEntity(&resourceIdentifier);
  500|      0|    }
  501|       |
  502|       |    //
  503|       |    //  If they didn't create a source via the entity resolver, then we
  504|       |    //  have to create one on our own.
  505|       |    //
  506|  2.00k|    if (!srcToFill)
  ------------------
  |  Branch (506:9): [True: 2.00k, False: 0]
  ------------------
  507|  2.00k|    {
  508|  2.00k|        if (disableDefaultEntityResolution)
  ------------------
  |  Branch (508:13): [True: 0, False: 2.00k]
  ------------------
  509|      0|            return 0;
  510|       |
  511|  2.00k|        LastExtEntityInfo lastInfo;
  512|  2.00k|        getLastExtEntityInfo(lastInfo);
  513|       |
  514|       |// Keep this #if 0 block as it was exposing a threading problem on AIX.
  515|       |// Got rid of the problem by changing XMLURL to not throw malformedurl
  516|       |// exceptions.
  517|       |#if 0
  518|       |        try
  519|       |        {
  520|       |            XMLURL urlTmp(lastInfo.systemId, expSysId.getRawBuffer(), fMemoryManager);
  521|       |            if (urlTmp.isRelative())
  522|       |            {
  523|       |                ThrowXMLwithMemMgr
  524|       |                (
  525|       |                    MalformedURLException
  526|       |                    , XMLExcepts::URL_NoProtocolPresent
  527|       |                    , fMemoryManager
  528|       |                );
  529|       |            }
  530|       |            else {
  531|       |                if (fStandardUriConformant && urlTmp.hasInvalidChar())
  532|       |                    ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager);
  533|       |                srcToFill = new (fMemoryManager) URLInputSource(urlTmp, fMemoryManager);
  534|       |            }
  535|       |        }
  536|       |
  537|       |        catch(const MalformedURLException& e)
  538|       |        {
  539|       |            // Its not a URL, so lets assume its a local file name if non-standard uri is allowed
  540|       |            if (!fStandardUriConformant)
  541|       |                srcToFill = new (fMemoryManager) LocalFileInputSource
  542|       |                (
  543|       |                    lastInfo.systemId
  544|       |                    , expSysId.getRawBuffer()
  545|       |                    , fMemoryManager
  546|       |                );
  547|       |            else
  548|       |                throw e;
  549|       |        }
  550|       |#else
  551|  2.00k|        XMLURL urlTmp(fMemoryManager);
  552|  2.00k|        if ((!urlTmp.setURL(lastInfo.systemId, expSysId.getRawBuffer(), urlTmp)) ||
  ------------------
  |  Branch (552:13): [True: 2.00k, False: 0]
  ------------------
  553|  2.00k|            (urlTmp.isRelative()))
  ------------------
  |  Branch (553:13): [True: 0, False: 0]
  ------------------
  554|  2.00k|        {
  555|  2.00k|            if (!fStandardUriConformant)
  ------------------
  |  Branch (555:17): [True: 2.00k, False: 0]
  ------------------
  556|  2.00k|            {
  557|  2.00k|                XMLBuffer resolvedSysId(1023, fMemoryManager);
  558|  2.00k|                XMLUri::normalizeURI(expSysId.getRawBuffer(), resolvedSysId);
  559|       |
  560|  2.00k|                srcToFill = new (fMemoryManager) LocalFileInputSource
  561|  2.00k|                (
  562|  2.00k|                    lastInfo.systemId
  563|  2.00k|                    , resolvedSysId.getRawBuffer()
  564|  2.00k|                    , fMemoryManager
  565|  2.00k|                );
  566|  2.00k|            }
  567|      0|            else
  568|      0|                ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  569|  2.00k|        }
  570|      0|        else
  571|      0|        {
  572|      0|            if (fStandardUriConformant && urlTmp.hasInvalidChar())
  ------------------
  |  Branch (572:17): [True: 0, False: 0]
  |  Branch (572:43): [True: 0, False: 0]
  ------------------
  573|      0|                ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  574|      0|            srcToFill = new (fMemoryManager) URLInputSource(urlTmp, fMemoryManager);
  575|      0|        }
  576|  2.00k|#endif
  577|  2.00k|    }
  578|       |
  579|       |    // Put a janitor on the input source
  580|  2.00k|    Janitor<InputSource> janSrc(srcToFill);
  581|       |
  582|       |    //
  583|       |    //  Now call the other version with the input source that we have, and
  584|       |    //  return the resulting reader.
  585|       |    //
  586|  2.00k|    XMLReader* retVal = createReader
  587|  2.00k|    (
  588|  2.00k|        *srcToFill
  589|  2.00k|        , xmlDecl
  590|  2.00k|        , refFrom
  591|  2.00k|        , type
  592|  2.00k|        , source
  593|  2.00k|        , calcSrcOfs
  594|  2.00k|        , lowWaterMark
  595|  2.00k|    );
  596|       |
  597|       |    // Either way, we can release the input source now
  598|  2.00k|    janSrc.orphan();
  599|       |
  600|       |    // If it failed for any reason, then return zero.
  601|  2.00k|    if (!retVal)
  ------------------
  |  Branch (601:9): [True: 2.00k, False: 0]
  ------------------
  602|  2.00k|        return 0;
  603|       |
  604|       |    // Give this reader the next available reader number and return it
  605|      0|    retVal->setReaderNum(fNextReaderNum++);
  606|      0|    return retVal;
  607|  2.00k|}
_ZN11xercesc_3_29ReaderMgr12createReaderEPKDsS2_S2_bNS_9XMLReader7RefFromENS3_5TypesENS3_7SourcesERPNS_11InputSourceEbmb:
  621|    392|{
  622|       |    //Normalize sysId
  623|    392|    XMLBuffer normalizedSysId(1023, fMemoryManager);
  624|    392|    XMLString::removeChar(sysId, 0xFFFF, normalizedSysId);
  625|    392|    const XMLCh* normalizedURI = normalizedSysId.getRawBuffer();
  626|       |
  627|       |    // Create a buffer for expanding the system id
  628|    392|    XMLBuffer expSysId(1023, fMemoryManager);
  629|       |
  630|       |    //
  631|       |    //  Allow the entity handler to expand the system id if they choose
  632|       |    //  to do so.
  633|       |    //
  634|    392|    if (fEntityHandler)
  ------------------
  |  Branch (634:9): [True: 0, False: 392]
  ------------------
  635|      0|    {
  636|      0|        if (!fEntityHandler->expandSystemId(normalizedURI, expSysId))
  ------------------
  |  Branch (636:13): [True: 0, False: 0]
  ------------------
  637|      0|            expSysId.set(normalizedURI);
  638|      0|    }
  639|    392|     else
  640|    392|    {
  641|    392|        expSysId.set(normalizedURI);
  642|    392|    }
  643|       |
  644|       |    // Call the entity resolver interface to get an input source
  645|    392|    srcToFill = 0;
  646|    392|    if (fEntityHandler)
  ------------------
  |  Branch (646:9): [True: 0, False: 392]
  ------------------
  647|      0|    {
  648|      0|        XMLResourceIdentifier resourceIdentifier(XMLResourceIdentifier::ExternalEntity,
  649|      0|                            expSysId.getRawBuffer(), XMLUni::fgZeroLenString, pubId, baseURI,
  650|      0|                            this);
  651|      0|        srcToFill = fEntityHandler->resolveEntity(&resourceIdentifier);
  652|      0|    }
  653|       |
  654|       |    //
  655|       |    //  If they didn't create a source via the entity resolver, then we
  656|       |    //  have to create one on our own.
  657|       |    //
  658|    392|    if (!srcToFill)
  ------------------
  |  Branch (658:9): [True: 392, False: 0]
  ------------------
  659|    392|    {
  660|    392|        if (disableDefaultEntityResolution)
  ------------------
  |  Branch (660:13): [True: 0, False: 392]
  ------------------
  661|      0|            return 0;
  662|       |
  663|    392|        LastExtEntityInfo lastInfo;
  664|       |
  665|    392|        const XMLCh* baseuri=baseURI;
  666|    392|        if(!baseuri || !*baseuri)
  ------------------
  |  Branch (666:12): [True: 0, False: 392]
  |  Branch (666:24): [True: 0, False: 392]
  ------------------
  667|      0|        {
  668|      0|            getLastExtEntityInfo(lastInfo);
  669|      0|            baseuri = lastInfo.systemId;
  670|      0|        }
  671|       |
  672|    392|        XMLURL urlTmp(fMemoryManager);
  673|    392|        if ((!urlTmp.setURL(baseuri, expSysId.getRawBuffer(), urlTmp)) ||
  ------------------
  |  Branch (673:13): [True: 242, False: 150]
  ------------------
  674|    392|            (urlTmp.isRelative()))
  ------------------
  |  Branch (674:13): [True: 0, False: 150]
  ------------------
  675|    235|        {
  676|    235|            if (!fStandardUriConformant)
  ------------------
  |  Branch (676:17): [True: 235, False: 0]
  ------------------
  677|    235|            {
  678|    235|                XMLBuffer resolvedSysId(1023, fMemoryManager);
  679|    235|                XMLUri::normalizeURI(expSysId.getRawBuffer(), resolvedSysId);
  680|       |
  681|    235|                srcToFill = new (fMemoryManager) LocalFileInputSource
  682|    235|                (
  683|    235|                    baseuri
  684|    235|                    , resolvedSysId.getRawBuffer()
  685|    235|                    , fMemoryManager
  686|    235|                );
  687|    235|            }
  688|      0|            else
  689|      0|                ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  690|    235|        }
  691|    157|        else
  692|    157|        {
  693|    157|            if (fStandardUriConformant && urlTmp.hasInvalidChar())
  ------------------
  |  Branch (693:17): [True: 0, False: 157]
  |  Branch (693:43): [True: 0, False: 0]
  ------------------
  694|      0|                ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_MalformedURL, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  695|    157|            srcToFill = new (fMemoryManager) URLInputSource(urlTmp, fMemoryManager);
  696|    157|        }
  697|    392|    }
  698|       |
  699|       |    // Put a janitor on the input source
  700|    392|    Janitor<InputSource> janSrc(srcToFill);
  701|       |
  702|       |    //
  703|       |    //  Now call the other version with the input source that we have, and
  704|       |    //  return the resulting reader.
  705|       |    //
  706|    392|    XMLReader* retVal = createReader
  707|    392|    (
  708|    392|        *srcToFill
  709|    392|        , xmlDecl
  710|    392|        , refFrom
  711|    392|        , type
  712|    392|        , source
  713|    392|        , calcSrcOfs
  714|    392|        , lowWaterMark
  715|    392|    );
  716|       |
  717|       |    // Either way, we can release the input source now
  718|    392|    janSrc.orphan();
  719|       |
  720|       |    // If it failed for any reason, then return zero.
  721|    392|    if (!retVal)
  ------------------
  |  Branch (721:9): [True: 93, False: 299]
  ------------------
  722|     93|        return 0;
  723|       |
  724|       |    // Give this reader the next available reader number and return it
  725|    299|    retVal->setReaderNum(fNextReaderNum++);
  726|    299|    return retVal;
  727|    392|}
_ZN11xercesc_3_29ReaderMgr18createIntEntReaderEPKDsNS_9XMLReader7RefFromENS3_5TypesES2_mbbm:
  739|  16.8k|{
  740|       |    //
  741|       |    //  This one is easy, we just create an input stream for the data and
  742|       |    //  provide a few extra goodies.
  743|       |    //
  744|       |    //  NOTE: We use a special encoding string that will be recognized
  745|       |    //  as a 'do nothing' transcoder for the already internalized XMLCh
  746|       |    //  data that makes up an internal entity.
  747|       |    //
  748|  16.8k|    BinMemInputStream* newStream = new (fMemoryManager) BinMemInputStream
  749|  16.8k|                                   (
  750|  16.8k|                                     (const XMLByte*)dataBuf
  751|  16.8k|                                     , dataLen * sizeof(XMLCh)
  752|  16.8k|                                     , copyBuf ? BinMemInputStream::BufOpt_Copy
  ------------------
  |  Branch (752:40): [True: 0, False: 16.8k]
  ------------------
  753|  16.8k|                                               : BinMemInputStream::BufOpt_Reference
  754|  16.8k|                                     , fMemoryManager
  755|  16.8k|                                   );
  756|  16.8k|    if (!newStream)
  ------------------
  |  Branch (756:9): [True: 0, False: 16.8k]
  ------------------
  757|      0|        return 0;
  758|       |
  759|  16.8k|    XMLReader* retVal = new (fMemoryManager) XMLReader
  760|  16.8k|    (
  761|  16.8k|        sysId
  762|  16.8k|        , 0
  763|  16.8k|        , newStream
  764|  16.8k|        , XMLRecognizer::XERCES_XMLCH
  765|  16.8k|        , refFrom
  766|  16.8k|        , type
  767|  16.8k|        , XMLReader::Source_Internal
  768|  16.8k|        , false
  769|  16.8k|        , calcSrcOfs
  770|  16.8k|        , lowWaterMark
  771|  16.8k|        , fXMLVersion
  772|  16.8k|        , fMemoryManager
  773|  16.8k|    );
  774|       |
  775|       |    // If it failed for any reason, then return zero.
  776|  16.8k|    if (!retVal) {
  ------------------
  |  Branch (776:9): [True: 0, False: 16.8k]
  ------------------
  777|      0|        delete newStream;
  778|      0|        return 0;
  779|      0|    }
  780|       |
  781|       |    // Set the reader number to the next available number
  782|  16.8k|    retVal->setReaderNum(fNextReaderNum++);
  783|  16.8k|    return retVal;
  784|  16.8k|}
_ZNK11xercesc_3_29ReaderMgr21getCurrentEncodingStrEv:
  788|  8.50k|{
  789|  8.50k|    const XMLEntityDecl*    theEntity;
  790|  8.50k|    const XMLReader*        theReader = getLastExtEntity(theEntity);
  791|       |
  792|  8.50k|    return theReader->getEncodingStr();
  793|  8.50k|}
_ZNK11xercesc_3_29ReaderMgr14getReaderDepthEv:
  809|  2.62k|{
  810|       |    // If the stack doesn't exist, its obviously zero
  811|  2.62k|    if (!fEntityStack)
  ------------------
  |  Branch (811:9): [True: 0, False: 2.62k]
  ------------------
  812|      0|        return 0;
  813|       |
  814|       |    //
  815|       |    //  The return is the stack size, plus one if there is a current
  816|       |    //  reader. So if there is no current reader and none on the stack,
  817|       |    //  its zero, else its some non-zero value.
  818|       |    //
  819|  2.62k|    XMLSize_t retVal = fEntityStack->size();
  820|  2.62k|    if (fCurReader)
  ------------------
  |  Branch (820:9): [True: 2.62k, False: 0]
  ------------------
  821|  2.62k|        retVal++;
  822|  2.62k|    return retVal;
  823|  2.62k|}
_ZNK11xercesc_3_29ReaderMgr20getLastExtEntityInfoERNS0_17LastExtEntityInfoE:
  826|  6.26k|{
  827|       |    //
  828|       |    //  If the reader stack never got created or we've not managed to open any
  829|       |    //  main entity yet, then we can't give this information.
  830|       |    //
  831|  6.26k|    if (!fReaderStack || !fCurReader)
  ------------------
  |  Branch (831:9): [True: 0, False: 6.26k]
  |  Branch (831:26): [True: 0, False: 6.26k]
  ------------------
  832|      0|    {
  833|      0|        lastInfo.systemId = XMLUni::fgZeroLenString;
  834|      0|        lastInfo.publicId = XMLUni::fgZeroLenString;
  835|      0|        lastInfo.lineNumber = 0;
  836|      0|        lastInfo.colNumber = 0;
  837|      0|        return;
  838|      0|    }
  839|       |
  840|       |    // We have at least one entity so get the data
  841|  6.26k|    const XMLEntityDecl*    theEntity;
  842|  6.26k|    const XMLReader*        theReader = getLastExtEntity(theEntity);
  843|       |
  844|       |    // Fill in the info structure with the reader we found
  845|  6.26k|    lastInfo.systemId = theReader->getSystemId();
  846|  6.26k|    lastInfo.publicId = theReader->getPublicId();
  847|  6.26k|    lastInfo.lineNumber = theReader->getLineNumber();
  848|  6.26k|    lastInfo.colNumber = theReader->getColumnNumber();
  849|  6.26k|}
_ZN11xercesc_3_29ReaderMgr10pushReaderEPNS_9XMLReaderEPNS_13XMLEntityDeclE:
  873|  25.4k|{
  874|       |    //
  875|       |    //  First, if an entity was passed, we have to confirm that this entity
  876|       |    //  is not already on the entity stack. If so, then this is a recursive
  877|       |    //  entity expansion, so we issue an error and refuse to put the reader
  878|       |    //  on the stack.
  879|       |    //
  880|       |    //  If there is no entity passed, then its not an entity being pushed, so
  881|       |    //  nothing to do. If there is no entity stack yet, then of coures it
  882|       |    //  cannot already be there.
  883|       |    //
  884|  25.4k|    if (entity && fEntityStack)
  ------------------
  |  Branch (884:9): [True: 16.8k, False: 8.51k]
  |  Branch (884:19): [True: 16.8k, False: 0]
  ------------------
  885|  16.8k|    {
  886|  16.8k|        const XMLSize_t count = fEntityStack->size();
  887|  16.8k|        const XMLCh* const theName = entity->getName();
  888|  30.6k|        for (XMLSize_t index = 0; index < count; index++)
  ------------------
  |  Branch (888:35): [True: 13.7k, False: 16.8k]
  ------------------
  889|  13.7k|        {
  890|  13.7k|            const XMLEntityDecl* curDecl = fEntityStack->elementAt(index);
  891|  13.7k|            if (curDecl)
  ------------------
  |  Branch (891:17): [True: 1.08k, False: 12.6k]
  ------------------
  892|  1.08k|            {
  893|  1.08k|                if (XMLString::equals(theName, curDecl->getName()))
  ------------------
  |  Branch (893:21): [True: 15, False: 1.06k]
  ------------------
  894|     15|                {
  895|       |                    // Oops, already there so delete reader and return
  896|     15|                    delete reader;
  897|     15|                    return false;
  898|     15|                }
  899|  1.08k|            }
  900|  13.7k|        }
  901|  16.8k|    }
  902|       |
  903|       |    //
  904|       |    //  Fault in the reader stack. Give it an initial capacity of 16, and
  905|       |    //  tell it it does own its elements.
  906|       |    //
  907|  25.3k|    if (!fReaderStack)
  ------------------
  |  Branch (907:9): [True: 8.51k, False: 16.8k]
  ------------------
  908|  8.51k|        fReaderStack = new (fMemoryManager) RefStackOf<XMLReader>(16, true, fMemoryManager);
  909|       |
  910|       |    // And the entity stack, which does not own its elements
  911|  25.3k|    if (!fEntityStack)
  ------------------
  |  Branch (911:9): [True: 8.51k, False: 16.8k]
  ------------------
  912|  8.51k|        fEntityStack = new (fMemoryManager) RefStackOf<XMLEntityDecl>(16, false, fMemoryManager);
  913|       |
  914|       |    //
  915|       |    //  Push the current reader and entity onto their respective stacks.
  916|       |    //  Note that the the current entity can be null if the current reader
  917|       |    //  is not for an entity.
  918|       |    //
  919|  25.3k|    if (fCurReader)
  ------------------
  |  Branch (919:9): [True: 16.8k, False: 8.51k]
  ------------------
  920|  16.8k|    {
  921|  16.8k|        fReaderStack->push(fCurReader);
  922|  16.8k|        fEntityStack->push(fCurEntity);
  923|  16.8k|    }
  924|       |
  925|       |    //
  926|       |    //  Make the passed reader and entity the current top of stack. The
  927|       |    //  passed entity can (and often is) null.
  928|       |    //
  929|  25.3k|    fCurReader = reader;
  930|  25.3k|    fCurEntity = entity;
  931|       |
  932|  25.3k|    return true;
  933|  25.4k|}
_ZN11xercesc_3_29ReaderMgr5resetEv:
  937|  8.51k|{
  938|       |    // Reset all of the flags
  939|  8.51k|    fThrowEOE = false;
  940|       |
  941|       |    // Delete the current reader and flush the reader stack
  942|  8.51k|    delete fCurReader;
  943|  8.51k|    fCurReader = 0;
  944|  8.51k|    if (fReaderStack)
  ------------------
  |  Branch (944:9): [True: 8.51k, False: 2]
  ------------------
  945|  8.51k|        fReaderStack->removeAllElements();
  946|       |
  947|       |    //
  948|       |    //  And do the same for the entity stack, but don't delete the current
  949|       |    //  entity (if any) since we don't own them.
  950|       |    //
  951|  8.51k|    fCurEntity = 0;
  952|  8.51k|    if (fEntityStack)
  ------------------
  |  Branch (952:9): [True: 8.51k, False: 2]
  ------------------
  953|  8.51k|        fEntityStack->removeAllElements();
  954|  8.51k|}
_ZNK11xercesc_3_29ReaderMgr16getLastExtEntityERPKNS_13XMLEntityDeclE:
 1003|  14.7k|{
 1004|       |    //
 1005|       |    //  Scan down the reader stack until we find a reader for an entity that
 1006|       |    //  is external. First check that there is anything in the stack at all,
 1007|       |    //  in which case the current reader is the main file and that's the one
 1008|       |    //  that we want.
 1009|       |    //
 1010|  14.7k|    const XMLReader* theReader = fCurReader;
 1011|       |
 1012|       |    //
 1013|       |    //  If there is a current entity and it is not an external entity, then
 1014|       |    //  search the stack; else, keep the reader that we've got since its
 1015|       |    //  either an external entity reader or the main file reader.
 1016|       |    //
 1017|  14.7k|    const XMLEntityDecl* curEntity = fCurEntity;
 1018|  14.7k|    if (curEntity && !curEntity->isExternal())
  ------------------
  |  Branch (1018:9): [True: 0, False: 14.7k]
  |  Branch (1018:22): [True: 0, False: 0]
  ------------------
 1019|      0|    {
 1020|      0|        XMLSize_t index = fReaderStack->size();
 1021|      0|        if (index)
  ------------------
  |  Branch (1021:13): [True: 0, False: 0]
  ------------------
 1022|      0|        {
 1023|      0|            while (true)
  ------------------
  |  Branch (1023:20): [Folded - Ignored]
  ------------------
 1024|      0|            {
 1025|       |                // Move down to the previous element and get a pointer to it
 1026|      0|                index--;
 1027|      0|                curEntity = fEntityStack->elementAt(index);
 1028|       |
 1029|       |                //
 1030|       |                //  If its null or its an external entity, then this reader
 1031|       |                //  is what we want, so break out with that one.
 1032|       |                //
 1033|      0|                if (!curEntity)
  ------------------
  |  Branch (1033:21): [True: 0, False: 0]
  ------------------
 1034|      0|                {
 1035|      0|                    theReader = fReaderStack->elementAt(index);
 1036|      0|                    break;
 1037|      0|                }
 1038|      0|                 else if (curEntity->isExternal())
  ------------------
  |  Branch (1038:27): [True: 0, False: 0]
  ------------------
 1039|      0|                {
 1040|      0|                    theReader = fReaderStack->elementAt(index);
 1041|      0|                    break;
 1042|      0|                }
 1043|       |
 1044|       |                // We hit the end, so leave the main file reader as the one
 1045|      0|                if (!index)
  ------------------
  |  Branch (1045:21): [True: 0, False: 0]
  ------------------
 1046|      0|                    break;
 1047|      0|            }
 1048|      0|        }
 1049|      0|    }
 1050|       |
 1051|  14.7k|    itsEntity = curEntity;
 1052|  14.7k|    return theReader;
 1053|  14.7k|}
_ZN11xercesc_3_29ReaderMgr9popReaderEv:
 1057|  18.5k|{
 1058|       |    //
 1059|       |    //  We didn't get any more, so try to pop off a reader. If the reader
 1060|       |    //  stack is empty, then we are at the end, so return false.
 1061|       |    //
 1062|  18.5k|    if (fReaderStack->empty())
  ------------------
  |  Branch (1062:9): [True: 2.67k, False: 15.8k]
  ------------------
 1063|  2.67k|        return false;
 1064|       |
 1065|       |    //
 1066|       |    //  Remember the current entity, before we pop off a new one. We might
 1067|       |    //  need this to throw the end of entity exception at the end.
 1068|       |    //
 1069|  15.8k|    XMLEntityDecl* prevEntity = fCurEntity;
 1070|  15.8k|    const bool prevReaderThrowAtEnd = fCurReader->getThrowAtEnd();
 1071|  15.8k|    const XMLSize_t readerNum = fCurReader->getReaderNum();
 1072|       |
 1073|       |    //
 1074|       |    //  Delete the current reader and pop a new reader and entity off
 1075|       |    //  the stacks.
 1076|       |    //
 1077|  15.8k|    delete fCurReader;
 1078|  15.8k|    fCurReader = fReaderStack->pop();
 1079|  15.8k|    fCurEntity = fEntityStack->pop();
 1080|       |
 1081|       |    //
 1082|       |    //  If there was a previous entity, and either the fThrowEOE flag is set
 1083|       |    //  or reader was marked as such, then throw an end of entity.
 1084|       |    //
 1085|  15.8k|    if (prevEntity && (fThrowEOE || prevReaderThrowAtEnd))
  ------------------
  |  Branch (1085:9): [True: 15.8k, False: 0]
  |  Branch (1085:24): [True: 5.45k, False: 10.3k]
  |  Branch (1085:37): [True: 0, False: 10.3k]
  ------------------
 1086|  5.45k|        throw EndOfEntityException(prevEntity, readerNum);
 1087|       |
 1088|  11.3k|    while (true)
  ------------------
  |  Branch (1088:12): [Folded - Ignored]
  ------------------
 1089|  11.3k|    {
 1090|       |        //
 1091|       |        //  They don't want us to throw, so lets just return with a new
 1092|       |        //  reader. Here we have to do a loop because we might have multiple
 1093|       |        //  readers on these stack that are empty (i.e. the last char in them
 1094|       |        //  was the ';' at the end of the entity ref that caused the next
 1095|       |        //  entity to be pushed.
 1096|       |        //
 1097|       |        //  So we loop until we find a non-empty reader, or hit the main
 1098|       |        //  file entity. If we find one with some chars available, then break
 1099|       |        //  out and take that one.
 1100|       |        //
 1101|  11.3k|        if (fCurReader->charsLeftInBuffer())
  ------------------
  |  Branch (1101:13): [True: 10.3k, False: 1.06k]
  ------------------
 1102|  10.3k|            break;
 1103|       |
 1104|  1.06k|        fCurReader->refreshCharBuffer();
 1105|  1.06k|        if (fCurReader->charsLeftInBuffer())
  ------------------
  |  Branch (1105:13): [True: 81, False: 980]
  ------------------
 1106|     81|            break;
 1107|       |
 1108|       |        //
 1109|       |        //  The current one is hosed. So, if the reader stack is empty we
 1110|       |        //  are dead meat and can give up now.
 1111|       |        //
 1112|    980|        if (fReaderStack->empty())
  ------------------
  |  Branch (1112:13): [True: 0, False: 980]
  ------------------
 1113|      0|            return false;
 1114|       |
 1115|       |        // Else pop again and try it one more time
 1116|    980|        delete fCurReader;
 1117|    980|        fCurReader = fReaderStack->pop();
 1118|    980|        fCurEntity = fEntityStack->pop();
 1119|    980|    }
 1120|  10.3k|    return true;
 1121|  10.3k|}

_ZN11xercesc_3_215ThrowEOEJanitorC2EPNS_9ReaderMgrEb:
  414|   705k|    {
  415|   705k|        mgrTarget->setThrowEOE(newValue);
  416|   705k|    }
_ZN11xercesc_3_215ThrowEOEJanitorD2Ev:
  419|   705k|    {
  420|   705k|        fMgr->setThrowEOE(fOld);
  421|   705k|    };
_ZNK11xercesc_3_29ReaderMgr19getCurrentReaderNumEv:
  277|  3.30M|{
  278|  3.30M|    return fCurReader->getReaderNum();
  279|  3.30M|}
_ZN11xercesc_3_29ReaderMgr16getCurrentReaderEv:
  287|   187M|{
  288|   187M|    return fCurReader;
  289|   187M|}
_ZN11xercesc_3_29ReaderMgr7getNameERNS_9XMLBufferE:
  292|  2.62M|{
  293|  2.62M|    toFill.reset();
  294|  2.62M|    return fCurReader->getName(toFill, false);
  295|  2.62M|}
_ZN11xercesc_3_29ReaderMgr12getNameTokenERNS_9XMLBufferE:
  304|    107|{
  305|    107|    toFill.reset();
  306|    107|    return fCurReader->getName(toFill, true);
  307|    107|}
_ZN11xercesc_3_29ReaderMgr16getNextCharIfNotEDsRDs:
  310|  2.02M|{
  311|  2.02M|    return fCurReader->getNextCharIfNot(chNotToGet, chGotten);
  312|  2.02M|}
_ZN11xercesc_3_29ReaderMgr21movePlainContentCharsERNS_9XMLBufferE:
  315|  1.15M|{
  316|  1.15M|    fCurReader->movePlainContentChars(dest);
  317|  1.15M|}
_ZNK11xercesc_3_29ReaderMgr11getThrowEOEEv:
  320|   705k|{
  321|   705k|    return fThrowEOE;
  322|   705k|}
_ZN11xercesc_3_29ReaderMgr13lookingAtCharEDs:
  330|  1.58M|{
  331|  1.58M|    return (chToCheck == peekNextChar());
  332|  1.58M|}
_ZN11xercesc_3_29ReaderMgr14lookingAtSpaceEv:
  335|  21.8k|{
  336|  21.8k|    XMLCh c = peekNextChar();
  337|  21.8k|    return fCurReader->isWhitespace(c);
  338|  21.8k|}
_ZN11xercesc_3_29ReaderMgr11setThrowEOEEb:
  341|  1.41M|{
  342|  1.41M|    fThrowEOE = newValue;
  343|  1.41M|}
_ZN11xercesc_3_29ReaderMgr13skippedStringEPKDs:
  351|   299k|{
  352|   299k|    return fCurReader->skippedString(toSkip);
  353|   299k|}
_ZN11xercesc_3_29ReaderMgr17skippedStringLongEPKDs:
  356|   136k|{
  357|   136k|    return fCurReader->skippedStringLong(toSkip);
  358|   136k|}
_ZN11xercesc_3_29ReaderMgr12skipPastCharEDs:
  373|  3.60k|{
  374|  3.60k|	XMLCh nextCh = 0;
  375|  3.60k|    do
  376|  3.60k|    {
  377|       |        // Get chars until we find the one to skip
  378|  3.60k|        nextCh = getNextChar();
  379|  3.60k|	}
  380|  3.60k|	while((nextCh != toSkipPast) && nextCh!=0);
  ------------------
  |  Branch (380:8): [True: 3.60k, False: 0]
  |  Branch (380:34): [True: 0, False: 3.60k]
  ------------------
  381|  3.60k|}
_ZN11xercesc_3_29ReaderMgr10peekStringEPKDs:
  384|  39.6k|{
  385|  39.6k|    return fCurReader->peekString(toPeek);
  386|  39.6k|}
_ZN11xercesc_3_29ReaderMgr13setXMLVersionENS_9XMLReader10XMLVersionE:
  394|  8.50k|{
  395|  8.50k|    fXMLVersion = version;
  396|  8.50k|    fCurReader->setXMLVersion(version);
  397|  8.50k|}

_ZN11xercesc_3_221ValidationContextImplD2Ev:
   41|  8.51k|{
   42|  8.51k|    if (fIdRefList)
  ------------------
  |  Branch (42:9): [True: 8.51k, False: 0]
  ------------------
   43|  8.51k|        delete fIdRefList;
   44|  8.51k|}
_ZN11xercesc_3_221ValidationContextImplC2EPNS_13MemoryManagerE:
   55|  8.51k|{
   56|  8.51k|    fIdRefList = new (fMemoryManager) RefHashTableOf<XMLRefInfo>(109, fMemoryManager);
   57|  8.51k|}
_ZNK11xercesc_3_221ValidationContextImpl12getIdRefListEv:
   64|  23.9k|{
   65|  23.9k|    return fIdRefList;
   66|  23.9k|}
_ZN11xercesc_3_221ValidationContextImpl14clearIdRefListEv:
   77|  8.51k|{
   78|  8.51k|    if (fIdRefList)
  ------------------
  |  Branch (78:9): [True: 8.51k, False: 0]
  ------------------
   79|  8.51k|        fIdRefList->removeAll();
   80|       |
   81|  8.51k|}
_ZN11xercesc_3_221ValidationContextImpl17setEntityDeclPoolEPKNS_10NameIdPoolINS_13DTDEntityDeclEEE:
  148|  8.51k|{
  149|       |    // we don't own it so we return the existing one for the owner to delete
  150|  8.51k|    const NameIdPool<DTDEntityDecl>* tempPool = fEntityDeclPool;
  151|  8.51k|    fEntityDeclPool = newEntityDeclPool;
  152|  8.51k|    return tempPool;
  153|       |
  154|  8.51k|}

_ZN11xercesc_3_221ValidationContextImpl12setElemStackEPNS_9ElemStackE:
  158|  8.51k|inline void ValidationContextImpl::setElemStack(ElemStack* elemStack) {
  159|  8.51k|    fElemStack = elemStack;
  160|  8.51k|}
_ZN11xercesc_3_221ValidationContextImpl10setScannerEPNS_10XMLScannerE:
  162|  8.51k|inline void ValidationContextImpl::setScanner(XMLScanner* scanner) {
  163|  8.51k|    fScanner = scanner;
  164|  8.51k|}

_ZN11xercesc_3_215VecAttrListImplC2Ev:
   39|  8.51k|{
   40|  8.51k|}
_ZN11xercesc_3_215VecAttrListImplD2Ev:
   43|  8.51k|{
   44|       |    //
   45|       |    //  Note that some compilers can't deal with the fact that the pointer
   46|       |    //  is to a const object, so we have to cast off the const'ness here!
   47|       |    //
   48|  8.51k|    if (fAdopt)
  ------------------
  |  Branch (48:9): [True: 0, False: 8.51k]
  ------------------
   49|      0|        delete (RefVectorOf<XMLAttr>*)fVector;
   50|  8.51k|}

_ZNK11xercesc_3_29XMLReader11isAllSpacesEPKDsm:
   45|   685k|{
   46|   685k|    const XMLCh* curCh = toCheck;
   47|   685k|    const XMLCh* endPtr = toCheck + count;
   48|  1.05M|    while (curCh < endPtr)
  ------------------
  |  Branch (48:12): [True: 711k, False: 344k]
  ------------------
   49|   711k|    {
   50|   711k|        if (!(fgCharCharsTable[*curCh++] & gWhitespaceCharMask))
  ------------------
  |  Branch (50:13): [True: 340k, False: 371k]
  ------------------
   51|   340k|            return false;
   52|   711k|    }
   53|   344k|    return true;
   54|   685k|}
_ZNK11xercesc_3_29XMLReader18containsWhiteSpaceEPKDsm:
   63|   368k|{
   64|   368k|    const XMLCh* curCh = toCheck;
   65|   368k|    const XMLCh* endPtr = toCheck + count;
   66|   870k|    while (curCh < endPtr)
  ------------------
  |  Branch (66:12): [True: 811k, False: 59.3k]
  ------------------
   67|   811k|    {
   68|   811k|        if (fgCharCharsTable[*curCh++] & gWhitespaceCharMask)
  ------------------
  |  Branch (68:13): [True: 309k, False: 502k]
  ------------------
   69|   309k|            return true;
   70|   811k|    }
   71|  59.3k|    return false;
   72|   368k|}
_ZNK11xercesc_3_29XMLReader14isPublicIdCharEDs:
   78|   580k|{
   79|   580k|    if (fXMLVersion == XMLV1_1)
  ------------------
  |  Branch (79:9): [True: 2.44k, False: 578k]
  ------------------
   80|  2.44k|        return XMLChar1_1::isPublicIdChar(toCheck);
   81|   578k|    else
   82|   578k|        return XMLChar1_0::isPublicIdChar(toCheck);
   83|   580k|}
_ZN11xercesc_3_29XMLReaderC2EPKDsS2_PNS_14BinInputStreamENS0_7RefFromENS0_5TypesENS0_7SourcesEbbmNS0_10XMLVersionEPNS_13MemoryManagerE:
  124|  8.52k|{
  125|  8.52k|    setXMLVersion(version);
  126|       |
  127|       |    // Do an initial load of raw bytes
  128|  8.52k|    refreshRawBuffer();
  129|       |
  130|       |    // Ask the transcoding service if it supports src offset info
  131|  8.52k|    fSrcOfsSupported = XMLPlatformUtils::fgTransService->supportsSrcOfs();
  132|       |
  133|       |    //
  134|       |    //  Use the recognizer class to get a basic sense of what family of
  135|       |    //  encodings this file is in. We'll start off with a reader of that
  136|       |    //  type, and update it later if needed when we read the XMLDecl line.
  137|       |    //
  138|  8.52k|    fEncoding = XMLRecognizer::basicEncodingProbe(fRawByteBuf, fRawBytesAvail);
  139|       |
  140|       |    #if defined(XERCES_DEBUG)
  141|       |    if ((fEncoding < XMLRecognizer::Encodings_Min)
  142|       |    ||  (fEncoding > XMLRecognizer::Encodings_Max))
  143|       |    {
  144|       |        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Reader_BadAutoEncoding, fMemoryManager);
  145|       |    }
  146|       |    #endif
  147|       |
  148|  8.52k|    fEncodingStr = XMLString::replicate(XMLRecognizer::nameForEncoding(fEncoding, fMemoryManager), fMemoryManager);
  149|       |
  150|       |    // Check whether the fSwapped flag should be set or not
  151|  8.52k|    checkForSwapped();
  152|       |
  153|       |    //
  154|       |    //  This will check to see if the first line is an XMLDecl and, if
  155|       |    //  so, decode that first line manually one character at a time. This
  156|       |    //  leaves enough characters in the buffer that the high level code
  157|       |    //  can get through the Decl and call us back with the real encoding.
  158|       |    //
  159|  8.52k|    doInitDecode();
  160|       |
  161|       |    //
  162|       |    //  NOTE: We won't create a transcoder until we either get a call to
  163|       |    //  setEncoding() or we get a call to refreshCharBuffer() and no
  164|       |    //  transcoder has been set yet.
  165|       |    //
  166|  8.52k|}
_ZN11xercesc_3_29XMLReaderC2EPKDsS2_PNS_14BinInputStreamENS_13XMLRecognizer9EncodingsENS0_7RefFromENS0_5TypesENS0_7SourcesEbbmNS0_10XMLVersionEPNS_13MemoryManagerE:
  390|  16.8k|{
  391|  16.8k|    setXMLVersion(version);
  392|       |
  393|       |    // Do an initial load of raw bytes
  394|  16.8k|    refreshRawBuffer();
  395|       |
  396|       |    // Ask the transcoding service if it supports src offset info
  397|  16.8k|    fSrcOfsSupported = XMLPlatformUtils::fgTransService->supportsSrcOfs();
  398|       |
  399|       |    //
  400|       |    //  Use the passed encoding code
  401|       |    //
  402|  16.8k|    fEncoding = encodingEnum;
  403|  16.8k|    fEncodingStr = XMLString::replicate(XMLRecognizer::nameForEncoding(fEncoding, fMemoryManager), fMemoryManager);
  404|       |
  405|       |    // Check whether the fSwapped flag should be set or not
  406|  16.8k|    checkForSwapped();
  407|       |
  408|       |    //
  409|       |    //  Create a transcoder for the encoding. Since the encoding has been
  410|       |    //  forced, this will be the one we will use, period.
  411|       |    //
  412|  16.8k|    XMLTransService::Codes failReason;
  413|  16.8k|    fTranscoder = XMLPlatformUtils::fgTransService->makeNewTranscoderFor
  414|  16.8k|    (
  415|  16.8k|        fEncoding
  416|  16.8k|        , failReason
  417|  16.8k|        , kCharBufSize
  418|  16.8k|        , fMemoryManager
  419|  16.8k|    );
  420|       |
  421|  16.8k|    if (!fTranscoder)
  ------------------
  |  Branch (421:9): [True: 0, False: 16.8k]
  ------------------
  422|      0|    {
  423|       |        // We are about to throw which means the d-tor won't be called.
  424|       |        // Clean up some memory.
  425|       |        //
  426|      0|        fMemoryManager->deallocate(fPublicId);
  427|      0|        fMemoryManager->deallocate(fSystemId);
  428|      0|        ArrayJanitor<XMLCh> jan (fEncodingStr, fMemoryManager);
  429|       |
  430|      0|        ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  431|      0|        (
  432|      0|            TranscodingException
  433|      0|            , XMLExcepts::Trans_CantCreateCvtrFor
  434|      0|            , fEncodingStr
  435|      0|            , fMemoryManager
  436|      0|        );
  437|      0|    }
  438|       |
  439|       |    //
  440|       |    //  Note that, unlike above, we do not do an initial decode of the
  441|       |    //  first line. We take the caller's word that the encoding is correct
  442|       |    //  and just assume that the first bulk decode (kicked off by the first
  443|       |    //  get of a character) will work.
  444|       |    //
  445|       |    //  So we do here the slipping in of the leading space if required.
  446|       |    //
  447|  16.8k|    if ((fType == Type_PE) && (fRefFrom == RefFrom_NonLiteral))
  ------------------
  |  Branch (447:9): [True: 751, False: 16.1k]
  |  Branch (447:31): [True: 751, False: 0]
  ------------------
  448|    751|    {
  449|       |        // This represents no data from the source
  450|    751|        fCharSizeBuf[fCharsAvail] = 0;
  451|    751|        fCharOfsBuf[fCharsAvail] = 0;
  452|    751|        fCharBuf[fCharsAvail++] = chSpace;
  453|    751|    }
  454|  16.8k|}
_ZN11xercesc_3_29XMLReaderD2Ev:
  458|  25.4k|{
  459|  25.4k|    fMemoryManager->deallocate(fEncodingStr);
  460|  25.4k|    fMemoryManager->deallocate(fPublicId);
  461|  25.4k|    fMemoryManager->deallocate(fSystemId);
  462|  25.4k|    delete fStream;
  463|  25.4k|    delete fTranscoder;
  464|  25.4k|}
_ZN11xercesc_3_29XMLReader17refreshCharBufferEv:
  493|  77.5k|{
  494|       |    // If the no more flag is set, then don't bother doing anything.
  495|  77.5k|    if (fNoMore)
  ------------------
  |  Branch (495:9): [True: 9.18k, False: 68.3k]
  ------------------
  496|  9.18k|        return false;
  497|       |
  498|  68.3k|    XMLSize_t startInd;
  499|       |
  500|       |    // See if we have any existing chars.
  501|  68.3k|    const XMLSize_t spareChars = fCharsAvail - fCharIndex;
  502|       |
  503|       |    // If we are full, then don't do anything.
  504|  68.3k|    if (spareChars == kCharBufSize)
  ------------------
  |  Branch (504:9): [True: 0, False: 68.3k]
  ------------------
  505|      0|        return true;
  506|       |
  507|       |    //
  508|       |    //  If no transcoder has been created yet, then we never saw the
  509|       |    //  any encoding="" string and the encoding was not forced, so lets
  510|       |    //  create one now. We know that it won't change now.
  511|       |    //
  512|       |    //  However, note that if we autosensed EBCDIC, then we have to
  513|       |    //  consider it an error if we never got an encoding since we don't
  514|       |    //  know what variant of EBCDIC it is.
  515|       |    //
  516|  68.3k|    if (!fTranscoder)
  ------------------
  |  Branch (516:9): [True: 881, False: 67.4k]
  ------------------
  517|    881|    {
  518|    881|        if (fEncoding == XMLRecognizer::EBCDIC)
  ------------------
  |  Branch (518:13): [True: 0, False: 881]
  ------------------
  519|      0|            ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Reader_EncodingStrRequired, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  520|       |
  521|       |        // Ask the transcoding service to make use a transcoder
  522|    881|        XMLTransService::Codes failReason;
  523|    881|        fTranscoder = XMLPlatformUtils::fgTransService->makeNewTranscoderFor
  524|    881|        (
  525|    881|            fEncodingStr
  526|    881|            , failReason
  527|    881|            , kCharBufSize
  528|    881|            , fMemoryManager
  529|    881|        );
  530|       |
  531|    881|        if (!fTranscoder)
  ------------------
  |  Branch (531:13): [True: 0, False: 881]
  ------------------
  532|      0|        {
  533|      0|            ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  534|      0|            (
  535|      0|                TranscodingException
  536|      0|                , XMLExcepts::Trans_CantCreateCvtrFor
  537|      0|                , fEncodingStr
  538|      0|                , fMemoryManager
  539|      0|            );
  540|      0|        }
  541|    881|    }
  542|       |
  543|       |    //
  544|       |    //  Add the number of source bytes eaten so far to the base src
  545|       |    //  offset member.
  546|       |    //
  547|  68.3k|    if (fCalculateSrcOfs) {
  ------------------
  |  Branch (547:9): [True: 47.3k, False: 20.9k]
  ------------------
  548|   146M|        for (startInd = 0; startInd < fCharIndex; startInd++)
  ------------------
  |  Branch (548:28): [True: 146M, False: 47.3k]
  ------------------
  549|   146M|            fSrcOfsBase += fCharSizeBuf[startInd];
  550|  47.3k|    }
  551|       |
  552|       |    //
  553|       |    //  If there are spare chars, then move then down to the bottom. We
  554|       |    //  have to move the char sizes down also.
  555|       |    //
  556|  68.3k|    startInd = 0;
  557|  68.3k|    if (spareChars)
  ------------------
  |  Branch (557:9): [True: 7.26k, False: 61.0k]
  ------------------
  558|  7.26k|    {
  559|  2.73M|        for (XMLSize_t index = fCharIndex; index < fCharsAvail; index++)
  ------------------
  |  Branch (559:44): [True: 2.72M, False: 7.26k]
  ------------------
  560|  2.72M|        {
  561|  2.72M|            fCharBuf[startInd] = fCharBuf[index];
  562|  2.72M|            fCharSizeBuf[startInd] = fCharSizeBuf[index];
  563|  2.72M|            startInd++;
  564|  2.72M|        }
  565|  7.26k|    }
  566|       |
  567|       |    //
  568|       |    //  And then get more chars, starting after any spare chars that were
  569|       |    //  left over from the last time.
  570|       |    //
  571|  68.3k|    fCharsAvail = xcodeMoreChars
  572|  68.3k|    (
  573|  68.3k|        &fCharBuf[startInd]
  574|  68.3k|        , &fCharSizeBuf[startInd]
  575|  68.3k|        , kCharBufSize - spareChars
  576|  68.3k|    );
  577|       |
  578|       |    // Add back in the spare chars
  579|  68.3k|    fCharsAvail += spareChars;
  580|       |
  581|       |    // Reset the buffer index to zero, so we start from the 0th char again
  582|  68.3k|    fCharIndex = 0;
  583|       |
  584|       |    //
  585|       |    //  If no chars available, then we have to check for one last thing. If
  586|       |    //  this is reader for a PE and its not being expanded inside a literal,
  587|       |    //  then unget a trailing space. We use a boolean to avoid triggering
  588|       |    //  this more than once.
  589|       |    //
  590|  68.3k|    if (!fCharsAvail
  ------------------
  |  Branch (590:9): [True: 19.7k, False: 48.5k]
  ------------------
  591|  68.3k|    &&  (fType == Type_PE)
  ------------------
  |  Branch (591:9): [True: 1.49k, False: 18.2k]
  ------------------
  592|  68.3k|    &&  (fRefFrom == RefFrom_NonLiteral)
  ------------------
  |  Branch (592:9): [True: 1.49k, False: 0]
  ------------------
  593|  68.3k|    &&  !fSentTrailingSpace)
  ------------------
  |  Branch (593:9): [True: 749, False: 749]
  ------------------
  594|    749|    {
  595|    749|        fCharBuf[0] = chSpace;
  596|    749|        fCharsAvail = 1;
  597|    749|        fSentTrailingSpace = true;
  598|    749|    }
  599|       |
  600|       |    //
  601|       |    //  If we get here with no more chars, then set the fNoMore flag which
  602|       |    //  lets us optimize and know without checking that no more chars are
  603|       |    //  available.
  604|       |    //
  605|  68.3k|    if (!fCharsAvail)
  ------------------
  |  Branch (605:9): [True: 18.9k, False: 49.3k]
  ------------------
  606|  18.9k|        fNoMore = true;
  607|       |
  608|       |    //  Calculate fCharOfsBuf using the elements from fCharBufSize
  609|  68.3k|    if (fCalculateSrcOfs)
  ------------------
  |  Branch (609:9): [True: 47.3k, False: 20.9k]
  ------------------
  610|  47.3k|    {
  611|  47.3k|        unsigned int last = 0;
  612|  47.3k|        fCharOfsBuf[0] = 0;
  613|   146M|        for (XMLSize_t index = 1; index < fCharsAvail; ++index) {
  ------------------
  |  Branch (613:35): [True: 146M, False: 47.3k]
  ------------------
  614|   146M|            fCharOfsBuf[index] = last+fCharSizeBuf[index-1];
  615|   146M|            last = fCharOfsBuf[index];
  616|       |            // code was:
  617|       |            // fCharOfsBuf[index] = fCharOfsBuf[index-1]+fCharSizeBuf[index-1];
  618|       |            // but on Solaris 64 bit with sun studio 11 this didn't work as
  619|       |            // every value of fCharOfsBuf[] was 1.
  620|   146M|        }
  621|  47.3k|    }
  622|       |
  623|  68.3k|    return (fCharsAvail != 0);
  624|  68.3k|}
_ZN11xercesc_3_29XMLReader7getNameERNS_9XMLBufferEb:
  632|  2.62M|{
  633|       |    //  Ok, first lets see if we have chars in the buffer. If not, then lets
  634|       |    //  reload.
  635|  2.62M|    if (fCharIndex == fCharsAvail)
  ------------------
  |  Branch (635:9): [True: 12, False: 2.62M]
  ------------------
  636|     12|    {
  637|     12|        if (!refreshCharBuffer())
  ------------------
  |  Branch (637:13): [True: 3, False: 9]
  ------------------
  638|      3|            return false;
  639|     12|    }
  640|       |
  641|  2.62M|    XMLSize_t charIndex_start = fCharIndex;
  642|       |
  643|       |    //  Lets check the first char for being a first name char. If not, then
  644|       |    //  what's the point in living mannnn? Just give up now. We only do this
  645|       |    //  if its a name and not a name token that they want.
  646|  2.62M|    if (!token)
  ------------------
  |  Branch (646:9): [True: 2.62M, False: 115]
  ------------------
  647|  2.62M|    {
  648|  2.62M|        if ((fCharBuf[fCharIndex] >= 0xD800) && (fCharBuf[fCharIndex] <= 0xDB7F)) {
  ------------------
  |  Branch (648:13): [True: 1.21k, False: 2.62M]
  |  Branch (648:49): [True: 900, False: 317]
  ------------------
  649|       |            // if there isn't one more char in the buffer, read more data
  650|    900|            if (fCharIndex+1 == fCharsAvail)
  ------------------
  |  Branch (650:17): [True: 259, False: 641]
  ------------------
  651|    259|            {
  652|    259|                if (!refreshCharBuffer())
  ------------------
  |  Branch (652:21): [True: 0, False: 259]
  ------------------
  653|      0|                    return false;
  654|       |                // reset the start buffer to the new location of the cursor
  655|    259|                charIndex_start = fCharIndex;
  656|    259|            }
  657|    900|            if ((fCharBuf[fCharIndex+1] < 0xDC00) || (fCharBuf[fCharIndex+1] > 0xDFFF))
  ------------------
  |  Branch (657:17): [True: 0, False: 900]
  |  Branch (657:54): [True: 0, False: 900]
  ------------------
  658|      0|                return false;
  659|       |
  660|       |            // Looks ok, so lets eat it
  661|    900|            fCharIndex += 2;
  662|    900|        }
  663|  2.62M|        else {
  664|  2.62M|            if (!isFirstNameChar(fCharBuf[fCharIndex]))
  ------------------
  |  Branch (664:17): [True: 406, False: 2.62M]
  ------------------
  665|    406|                return false;
  666|       |
  667|       |            // Looks ok, so lets eat it
  668|  2.62M|            fCharIndex ++;
  669|  2.62M|        }
  670|       |
  671|  2.62M|    }
  672|       |
  673|       |    //  And now we loop until we run out of data in this reader or we hit
  674|       |    //  a non-name char.
  675|  2.63M|    while (true)
  ------------------
  |  Branch (675:12): [Folded - Ignored]
  ------------------
  676|  2.63M|    {
  677|  60.7M|        while (fCharIndex < fCharsAvail)
  ------------------
  |  Branch (677:16): [True: 60.7M, False: 4.16k]
  ------------------
  678|  60.7M|        {
  679|       |            //  Check the current char and take it if its a name char. Else
  680|       |            //  break out.
  681|  60.7M|            if ( (fCharBuf[fCharIndex] >= 0xD800) && (fCharBuf[fCharIndex] <= 0xDB7F) )
  ------------------
  |  Branch (681:18): [True: 3.24k, False: 60.7M]
  |  Branch (681:54): [True: 2.69k, False: 556]
  ------------------
  682|  2.69k|            {
  683|       |                // if there isn't one more char in the buffer, read more data
  684|  2.69k|                if (fCharIndex+1 == fCharsAvail)
  ------------------
  |  Branch (684:21): [True: 286, False: 2.40k]
  ------------------
  685|    286|                {
  686|       |                    // but first copy the accepted character(s), and update column
  687|    286|                    if (fCharIndex != charIndex_start)
  ------------------
  |  Branch (687:25): [True: 286, False: 0]
  ------------------
  688|    286|                    {
  689|    286|                        fCurCol += (XMLFileLoc)(fCharIndex - charIndex_start);
  690|    286|                        toFill.append(&fCharBuf[charIndex_start], fCharIndex - charIndex_start);
  691|    286|                    }
  692|       |
  693|    286|                    if (!refreshCharBuffer())
  ------------------
  |  Branch (693:25): [True: 0, False: 286]
  ------------------
  694|      0|                        break;
  695|       |
  696|    286|                    charIndex_start = fCharIndex;
  697|    286|                }
  698|  2.69k|                if ( (fCharBuf[fCharIndex+1] < 0xDC00) ||
  ------------------
  |  Branch (698:22): [True: 0, False: 2.69k]
  ------------------
  699|  2.69k|                        (fCharBuf[fCharIndex+1] > 0xDFFF)  )
  ------------------
  |  Branch (699:25): [True: 0, False: 2.69k]
  ------------------
  700|      0|                    break;
  701|  2.69k|                fCharIndex += 2;
  702|       |
  703|  2.69k|            }
  704|  60.7M|            else
  705|  60.7M|            {
  706|  60.7M|                if (!isNameChar(fCharBuf[fCharIndex]))
  ------------------
  |  Branch (706:21): [True: 2.62M, False: 58.0M]
  ------------------
  707|  2.62M|                    break;
  708|  58.0M|                fCharIndex++;
  709|  58.0M|            }
  710|  60.7M|        }
  711|       |
  712|       |        // we have to copy the accepted character(s), and update column
  713|  2.63M|        if (fCharIndex != charIndex_start)
  ------------------
  |  Branch (713:13): [True: 2.63M, False: 686]
  ------------------
  714|  2.63M|        {
  715|  2.63M|            fCurCol += (XMLFileLoc)(fCharIndex - charIndex_start);
  716|  2.63M|            toFill.append(&fCharBuf[charIndex_start], fCharIndex - charIndex_start);
  717|  2.63M|        }
  718|       |
  719|       |        // something is wrong if there is still something in the buffer
  720|       |        // or if we don't get no more, then break out.
  721|  2.63M|        if ((fCharIndex < fCharsAvail) ||
  ------------------
  |  Branch (721:13): [True: 2.62M, False: 4.16k]
  ------------------
  722|  2.63M|             !refreshCharBuffer())
  ------------------
  |  Branch (722:14): [True: 84, False: 4.08k]
  ------------------
  723|  2.62M|            break;
  724|       |
  725|  4.15k|        charIndex_start = fCharIndex;
  726|  4.15k|    }
  727|       |
  728|  2.62M|    return !toFill.isEmpty();
  729|  2.62M|}
_ZN11xercesc_3_29XMLReader15getUpToCharOrWSERNS_9XMLBufferEDs:
  921|  24.6k|{
  922|  24.6k|    while (true)
  ------------------
  |  Branch (922:12): [Folded - Ignored]
  ------------------
  923|  24.6k|    {
  924|       |        // Loop through the current chars in the buffer
  925|   230k|        while (fCharIndex < fCharsAvail)
  ------------------
  |  Branch (925:16): [True: 230k, False: 0]
  ------------------
  926|   230k|        {
  927|       |            // Get the current char out of the buffer
  928|   230k|            XMLCh curCh = fCharBuf[fCharIndex];
  929|       |
  930|       |            //
  931|       |            //  See if its not a white space or our target char, then process
  932|       |            //  it. Else, we need to return.
  933|       |            //
  934|   230k|            if (!isWhitespace(curCh) && (curCh != toCheck))
  ------------------
  |  Branch (934:17): [True: 230k, False: 0]
  |  Branch (934:41): [True: 205k, False: 24.6k]
  ------------------
  935|   205k|            {
  936|       |                // Eat this char
  937|   205k|                fCharIndex++;
  938|       |
  939|       |                //
  940|       |                //  'curCh' is not a whitespace(x20|x9|xD|xA), so we only can
  941|       |                //  have end-of-line combinations with a leading chNEL(x85) or
  942|       |                //  chLineSeparator(x2028)
  943|       |                //
  944|       |                //  0010000000101000 chLineSeparator
  945|       |                //  0000000010000101 chNEL
  946|       |                //  ---------------------
  947|       |                //  1101111101010010 == ~(chNEL|chLineSeparator)
  948|       |                //
  949|       |                //  if the result of the logical-& operation is
  950|       |                //  true  : 'curCh' can not be chNEL or chLineSeparator
  951|       |                //  false : 'curCh' can be chNEL or chLineSeparator
  952|       |                //
  953|   205k|                if ( curCh & (XMLCh) ~(chNEL|chLineSeparator) )
  ------------------
  |  Branch (953:22): [True: 205k, False: 0]
  ------------------
  954|   205k|                {
  955|   205k|                    fCurCol++;
  956|   205k|                } else
  957|      0|                {
  958|      0|                    handleEOL(curCh, false);
  959|      0|                }
  960|       |
  961|       |                // Add it to our buffer
  962|   205k|                toFill.append(curCh);
  963|   205k|            }
  964|  24.6k|             else
  965|  24.6k|            {
  966|  24.6k|                return true;
  967|  24.6k|            }
  968|   230k|        }
  969|       |
  970|       |        //
  971|       |        //  We've eaten up the current buffer, so lets try to reload it. If
  972|       |        //  we don't get anything new, then break out. If we do, then we go
  973|       |        //  back to the top to keep getting spaces.
  974|       |        //
  975|      0|        if (!refreshCharBuffer())
  ------------------
  |  Branch (975:13): [True: 0, False: 0]
  ------------------
  976|      0|            break;
  977|      0|    }
  978|       |
  979|       |    // We never hit any non-space and ate up the whole reader
  980|      0|    return false;
  981|       |
  982|  24.6k|}
_ZN11xercesc_3_29XMLReader11skipIfQuoteERDs:
  985|   519k|{
  986|   519k|    if (fCharIndex == fCharsAvail && !refreshCharBuffer())
  ------------------
  |  Branch (986:9): [True: 2, False: 519k]
  |  Branch (986:38): [True: 2, False: 0]
  ------------------
  987|      2|        return false;
  988|       |
  989|   519k|    chGotten = fCharBuf[fCharIndex];
  990|   519k|    if ((chGotten == chDoubleQuote) || (chGotten == chSingleQuote))
  ------------------
  |  Branch (990:9): [True: 256k, False: 262k]
  |  Branch (990:40): [True: 262k, False: 92]
  ------------------
  991|   519k|    {
  992|   519k|        fCharIndex++;
  993|   519k|        fCurCol++;
  994|   519k|        return true;
  995|   519k|    }
  996|     92|    return false;
  997|   519k|}
_ZN11xercesc_3_29XMLReader10skipSpacesERbb:
 1001|  2.76M|{
 1002|       |    //  DO NOT set the skippedSomething to 'false', but change it to be 'true' only
 1003|       |
 1004|       |    //  We enter a loop where we skip over spaces until we hit the end of
 1005|       |    //  this reader or a non-space value. The return indicates whether we
 1006|       |    //  hit the non-space (true) or the end (false).
 1007|  2.76M|    do
 1008|  2.76M|    {
 1009|       |        // Loop through the current chars in the buffer
 1010|  4.01M|        while (fCharIndex < fCharsAvail)
  ------------------
  |  Branch (1010:16): [True: 4.01M, False: 2.32k]
  ------------------
 1011|  4.01M|        {
 1012|       |            //  See if its a white space char. If so, then process it. Else
 1013|       |            //  we've hit a non-space and need to return.
 1014|  4.01M|            if (isWhitespace(fCharBuf[fCharIndex]))
  ------------------
  |  Branch (1014:17): [True: 1.25M, False: 2.75M]
  ------------------
 1015|  1.25M|            {
 1016|       |                // Get the current char out of the buffer and eat it
 1017|  1.25M|                XMLCh curCh = fCharBuf[fCharIndex++];
 1018|  1.25M|                skippedSomething = true;
 1019|       |                //
 1020|       |                //  'curCh' is a whitespace(x20|x9|xD|xA), so we only can have
 1021|       |                //  end-of-line combinations with a leading chCR(xD) or chLF(xA)
 1022|       |                //
 1023|       |                //  100000 x20
 1024|       |                //  001001 x9
 1025|       |                //  001010 chLF
 1026|       |                //  001101 chCR
 1027|       |                //  -----------
 1028|       |                //  000110 == (chCR|chLF) & ~(0x9|0x20)
 1029|       |                //
 1030|       |                //  if the result of the logical-& operation is
 1031|       |                //  true  : 'curCh' must be xA  or xD
 1032|       |                //  false : 'curCh' must be x20 or x9
 1033|       |                //
 1034|  1.25M|                if ( ( curCh & (chCR|chLF) & ~(0x9|0x20) ) == 0 )
  ------------------
  |  Branch (1034:22): [True: 1.24M, False: 12.1k]
  ------------------
 1035|  1.24M|                {
 1036|  1.24M|                    fCurCol++;
 1037|  1.24M|                } else
 1038|  12.1k|                {
 1039|  12.1k|                    handleEOL(curCh, inDecl);
 1040|  12.1k|                }
 1041|  1.25M|            }
 1042|  2.75M|            else
 1043|  2.75M|                return true;
 1044|  4.01M|        }
 1045|       |
 1046|       |        //  We've eaten up the current buffer, so lets try to reload it. If
 1047|       |        //  we don't get anything new, then break out. If we do, then we go
 1048|       |        //  back to the top to keep getting spaces.
 1049|  2.76M|    } while(refreshCharBuffer());
  ------------------
  |  Branch (1049:13): [True: 1.02k, False: 1.29k]
  ------------------
 1050|       |
 1051|       |    // We never hit any non-space and ate up the whole reader
 1052|  1.29k|    return false;
 1053|  2.76M|}
_ZN11xercesc_3_29XMLReader11skippedCharEDs:
 1056|  7.22M|{
 1057|       |    //
 1058|       |    //  If the buffer is empty, then try to reload it. If we still get
 1059|       |    //  nothing, then return false.
 1060|       |    //
 1061|  7.22M|    if (fCharIndex == fCharsAvail)
  ------------------
  |  Branch (1061:9): [True: 233, False: 7.22M]
  ------------------
 1062|    233|    {
 1063|    233|        if (!refreshCharBuffer())
  ------------------
  |  Branch (1063:13): [True: 12, False: 221]
  ------------------
 1064|     12|            return false;
 1065|    233|    }
 1066|       |
 1067|       |    //
 1068|       |    //  See if the current char is the one we want. If so, then we need
 1069|       |    //  to eat it and return true.
 1070|       |    //
 1071|  7.22M|    if (fCharBuf[fCharIndex] == toSkip)
  ------------------
  |  Branch (1071:9): [True: 2.43M, False: 4.79M]
  ------------------
 1072|  2.43M|    {
 1073|  2.43M|        fCharIndex++;
 1074|  2.43M|        fCurCol++;
 1075|  2.43M|        return true;
 1076|  2.43M|    }
 1077|  4.79M|    return false;
 1078|  7.22M|}
_ZN11xercesc_3_29XMLReader12skippedSpaceEv:
 1082|  3.24M|{
 1083|       |    //
 1084|       |    //  If the buffer is empty, then try to reload it. If we still get
 1085|       |    //  nothing, then return false.
 1086|       |    //
 1087|  3.24M|    if (fCharIndex == fCharsAvail)
  ------------------
  |  Branch (1087:9): [True: 361, False: 3.24M]
  ------------------
 1088|    361|    {
 1089|    361|        if (!refreshCharBuffer())
  ------------------
  |  Branch (1089:13): [True: 7, False: 354]
  ------------------
 1090|      7|            return false;
 1091|    361|    }
 1092|       |
 1093|       |    //
 1094|       |    //  See if the current char is a whitespace. If so, then we need to eat
 1095|       |    //  it and return true.
 1096|       |    //
 1097|  3.24M|    const XMLCh curCh = fCharBuf[fCharIndex];
 1098|  3.24M|    if (isWhitespace(curCh))
  ------------------
  |  Branch (1098:9): [True: 114k, False: 3.13M]
  ------------------
 1099|   114k|    {
 1100|       |        // Eat the character
 1101|   114k|        fCharIndex++;
 1102|       |
 1103|       |        //
 1104|       |        //  'curCh' is a whitespace(x20|x9|xD|xA), so we only can have
 1105|       |        //  end-of-line combinations with a leading chCR(xD) or chLF(xA)
 1106|       |        //
 1107|       |        //  100000 x20
 1108|       |        //  001001 x9
 1109|       |        //  001010 chLF
 1110|       |        //  001101 chCR
 1111|       |        //  -----------
 1112|       |        //  000110 == (chCR|chLF) & ~(0x9|0x20)
 1113|       |        //
 1114|       |        //  if the result of the logical-& operation is
 1115|       |        //  true  : 'curCh' must be xA  or xD
 1116|       |        //  false : 'curCh' must be x20 or x9
 1117|       |        //
 1118|   114k|        if ( ( curCh & (chCR|chLF) & ~(0x9|0x20) ) == 0 )
  ------------------
  |  Branch (1118:14): [True: 112k, False: 2.17k]
  ------------------
 1119|   112k|        {
 1120|   112k|            fCurCol++;
 1121|   112k|        } else
 1122|  2.17k|        {
 1123|  2.17k|            handleEOL((XMLCh&)curCh, false);
 1124|  2.17k|        }
 1125|       |
 1126|   114k|        return true;
 1127|   114k|    }
 1128|  3.13M|    return false;
 1129|  3.24M|}
_ZN11xercesc_3_29XMLReader13skippedStringEPKDs:
 1132|   299k|{
 1133|       |    // This function works on strings that are smaller than kCharBufSize.
 1134|       |    // This function guarantees that in case the comparison is unsuccessful
 1135|       |    // the fCharIndex will point to the original data.
 1136|       |    //
 1137|       |
 1138|       |    // Get the length of the string to skip.
 1139|       |    //
 1140|   299k|    const XMLSize_t srcLen = XMLString::stringLen(toSkip);
 1141|   299k|    XMLSize_t charsLeft = charsLeftInBuffer();
 1142|       |
 1143|       |    //  See if the current reader has enough chars to test against this
 1144|       |    //  string. If not, then ask it to reload its buffer. If that does not
 1145|       |    //  get us enough, then it cannot match.
 1146|       |    //
 1147|       |    //  NOTE: This works because strings never have to cross a reader! And
 1148|       |    //  a string to skip will never have a new line in it, so we will never
 1149|       |    //  miss adjusting the current line.
 1150|       |    //
 1151|   300k|    while (charsLeft < srcLen)
  ------------------
  |  Branch (1151:12): [True: 8.62k, False: 292k]
  ------------------
 1152|  8.62k|    {
 1153|  8.62k|      if (!refreshCharBuffer())
  ------------------
  |  Branch (1153:11): [True: 3.35k, False: 5.27k]
  ------------------
 1154|  3.35k|        return false;
 1155|       |
 1156|  5.27k|      XMLSize_t tmp = charsLeftInBuffer();
 1157|  5.27k|      if (tmp == charsLeft) // if the refreshCharBuf() did not add anything new
  ------------------
  |  Branch (1157:11): [True: 4.36k, False: 904]
  ------------------
 1158|  4.36k|        return false;     // give up and return.
 1159|       |
 1160|    904|      charsLeft = tmp;
 1161|    904|    }
 1162|       |
 1163|       |    //  Ok, now we now that the current reader has enough chars in its
 1164|       |    //  buffer and that its index is back at zero. So we can do a quick and
 1165|       |    //  dirty comparison straight to its buffer with no requirement to unget
 1166|       |    //  if it fails.
 1167|       |    //
 1168|   292k|    if (memcmp(&fCharBuf[fCharIndex], toSkip, srcLen * sizeof(XMLCh)))
  ------------------
  |  Branch (1168:9): [True: 203k, False: 88.8k]
  ------------------
 1169|   203k|      return false;
 1170|       |
 1171|       |    // Add the source length to the current column to get it back right.
 1172|       |    //
 1173|  88.8k|    fCurCol += (XMLFileLoc)srcLen;
 1174|       |
 1175|       |    //  And get the character buffer index back right by just adding the
 1176|       |    //  source len to it.
 1177|       |    //
 1178|  88.8k|    fCharIndex += srcLen;
 1179|       |
 1180|  88.8k|    return true;
 1181|   292k|}
_ZN11xercesc_3_29XMLReader17skippedStringLongEPKDs:
 1184|   136k|{
 1185|       |    // This function works on strings that are potentially longer than
 1186|       |    // kCharBufSize (e.g., end tag). This function does not guarantee
 1187|       |    // that in case the comparison is unsuccessful the fCharIndex will
 1188|       |    // point to the original data.
 1189|       |    //
 1190|       |
 1191|   136k|    XMLSize_t srcLen = XMLString::stringLen(toSkip);
 1192|   136k|    XMLSize_t charsLeft = charsLeftInBuffer();
 1193|       |
 1194|   272k|    while (srcLen != 0)
  ------------------
  |  Branch (1194:12): [True: 136k, False: 136k]
  ------------------
 1195|   136k|    {
 1196|       |      // Fill up the buffer with as much data as possible.
 1197|       |      //
 1198|   136k|      while (charsLeft < srcLen && charsLeft != kCharBufSize)
  ------------------
  |  Branch (1198:14): [True: 723, False: 136k]
  |  Branch (1198:36): [True: 599, False: 124]
  ------------------
 1199|    599|      {
 1200|    599|        if (!refreshCharBuffer())
  ------------------
  |  Branch (1200:13): [True: 1, False: 598]
  ------------------
 1201|      1|          return false;
 1202|       |
 1203|    598|        XMLSize_t tmp = charsLeftInBuffer();
 1204|    598|        if (tmp == charsLeft) // if the refreshCharBuf() did not add anything
  ------------------
  |  Branch (1204:13): [True: 23, False: 575]
  ------------------
 1205|     23|          return false;       // new give up and return.
 1206|       |
 1207|    575|        charsLeft = tmp;
 1208|    575|      }
 1209|       |
 1210|   136k|      XMLSize_t n = charsLeft < srcLen ? charsLeft : srcLen;
  ------------------
  |  Branch (1210:21): [True: 124, False: 136k]
  ------------------
 1211|       |
 1212|   136k|      if (memcmp(&fCharBuf[fCharIndex], toSkip, n * sizeof(XMLCh)))
  ------------------
  |  Branch (1212:11): [True: 74, False: 136k]
  ------------------
 1213|     74|        return false;
 1214|       |
 1215|   136k|      toSkip += n;
 1216|   136k|      srcLen -= n;
 1217|       |
 1218|   136k|      fCharIndex += n;
 1219|   136k|      fCurCol += (XMLFileLoc)n;
 1220|   136k|      charsLeft -= n;
 1221|   136k|    }
 1222|       |
 1223|   136k|    return true;
 1224|   136k|}
_ZN11xercesc_3_29XMLReader10peekStringEPKDs:
 1232|  39.6k|{
 1233|       |    // Get the length of the string to skip
 1234|  39.6k|    const XMLSize_t srcLen = XMLString::stringLen(toPeek);
 1235|       |
 1236|       |    //
 1237|       |    //  See if the current reader has enough chars to test against this
 1238|       |    //  string. If not, then ask it to reload its buffer. If that does not
 1239|       |    //  get us enough, then it cannot match.
 1240|       |    //
 1241|       |    //  NOTE: This works because strings never have to cross a reader! And
 1242|       |    //  a string to skip will never have a new line in it, so we will never
 1243|       |    //  miss adjusting the current line.
 1244|       |    //
 1245|  39.6k|    XMLSize_t charsLeft = charsLeftInBuffer();
 1246|  48.7k|    while (charsLeft < srcLen)
  ------------------
  |  Branch (1246:12): [True: 10.9k, False: 37.7k]
  ------------------
 1247|  10.9k|    {
 1248|  10.9k|         refreshCharBuffer();
 1249|  10.9k|         XMLSize_t t = charsLeftInBuffer();
 1250|  10.9k|         if (t == charsLeft)   // if the refreshCharBuf() did not add anything new
  ------------------
  |  Branch (1250:14): [True: 1.82k, False: 9.11k]
  ------------------
 1251|  1.82k|             return false;     //   give up and return.
 1252|  9.11k|         charsLeft = t;
 1253|  9.11k|	}
 1254|       |
 1255|       |
 1256|       |
 1257|       |
 1258|       |    //
 1259|       |    //  Ok, now we now that the current reader has enough chars in its
 1260|       |    //  buffer and that its index is back at zero. So we can do a quick and
 1261|       |    //  dirty comparison straight to its buffer with no requirement to unget
 1262|       |    //  if it fails.
 1263|       |    //
 1264|  37.7k|    if (memcmp(&fCharBuf[fCharIndex], toPeek, srcLen*sizeof(XMLCh)))
  ------------------
  |  Branch (1264:9): [True: 28.8k, False: 8.97k]
  ------------------
 1265|  28.8k|        return false;
 1266|       |
 1267|  8.97k|    return true;
 1268|  37.7k|}
_ZN11xercesc_3_29XMLReader11setEncodingEPKDs:
 1275|  7.64k|{
 1276|       |    //
 1277|       |    //  If the encoding was forced, then we ignore the new value and just
 1278|       |    //  return with success. If it was forced, then we are to use that
 1279|       |    //  encoding without question. Note that, if we are forced, we created
 1280|       |    //  a transcoder up front so there is no need to do one here in that
 1281|       |    //  case.
 1282|       |    //
 1283|  7.64k|    if (fForcedEncoding)
  ------------------
  |  Branch (1283:9): [True: 0, False: 7.64k]
  ------------------
 1284|      0|        return true;
 1285|       |
 1286|       |    //
 1287|       |    // upperCase the newEncoding first for better performance
 1288|       |    //
 1289|  7.64k|    XMLCh* inputEncoding = XMLString::replicate(newEncoding, fMemoryManager);
 1290|  7.64k|    XMLString::upperCaseASCII(inputEncoding);
 1291|       |
 1292|  7.64k|    XMLRecognizer::Encodings newBaseEncoding;
 1293|       |    //
 1294|       |    //  Check for non-endian specific UTF-16 or UCS-4. If so, and if we
 1295|       |    //  are already in one of the endian versions of those encodings,
 1296|       |    //  then just keep it and go on. Otherwise, its not valid.
 1297|       |    //
 1298|  7.64k|    if (XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString)
  ------------------
  |  Branch (1298:9): [True: 23, False: 7.62k]
  ------------------
 1299|  7.64k|    ||  XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString2)
  ------------------
  |  Branch (1299:9): [True: 1, False: 7.62k]
  ------------------
 1300|  7.64k|    ||  XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString3)
  ------------------
  |  Branch (1300:9): [True: 1, False: 7.62k]
  ------------------
 1301|  7.64k|    ||  XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString4)
  ------------------
  |  Branch (1301:9): [True: 0, False: 7.62k]
  ------------------
 1302|  7.64k|    ||  XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString5)
  ------------------
  |  Branch (1302:9): [True: 1, False: 7.62k]
  ------------------
 1303|  7.64k|    ||  XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString6)
  ------------------
  |  Branch (1303:9): [True: 0, False: 7.62k]
  ------------------
 1304|  7.64k|    ||  XMLString::equals(inputEncoding, XMLUni::fgUTF16EncodingString7))
  ------------------
  |  Branch (1304:9): [True: 0, False: 7.62k]
  ------------------
 1305|     26|    {
 1306|     26|        fMemoryManager->deallocate(inputEncoding);
 1307|       |
 1308|     26|        if ((fEncoding != XMLRecognizer::UTF_16L)
  ------------------
  |  Branch (1308:13): [True: 26, False: 0]
  ------------------
 1309|     26|        &&  (fEncoding != XMLRecognizer::UTF_16B))
  ------------------
  |  Branch (1309:13): [True: 26, False: 0]
  ------------------
 1310|     26|        {
 1311|     26|            return false;
 1312|     26|        }
 1313|       |
 1314|       |        // Override with the original endian specific encoding
 1315|      0|        newBaseEncoding = fEncoding;
 1316|       |
 1317|      0|        if (fEncoding == XMLRecognizer::UTF_16L) {
  ------------------
  |  Branch (1317:13): [True: 0, False: 0]
  ------------------
 1318|      0|            fMemoryManager->deallocate(fEncodingStr);
 1319|      0|            fEncodingStr = 0;
 1320|      0|            fEncodingStr = XMLString::replicate(XMLUni::fgUTF16LEncodingString, fMemoryManager);
 1321|      0|        }
 1322|      0|        else {
 1323|      0|            fMemoryManager->deallocate(fEncodingStr);
 1324|      0|            fEncodingStr = 0;
 1325|      0|            fEncodingStr = XMLString::replicate(XMLUni::fgUTF16BEncodingString, fMemoryManager);
 1326|      0|        }
 1327|      0|    }
 1328|  7.62k|    else if (XMLString::equals(inputEncoding, XMLUni::fgUCS4EncodingString)
  ------------------
  |  Branch (1328:14): [True: 1, False: 7.61k]
  ------------------
 1329|  7.62k|         ||  XMLString::equals(inputEncoding, XMLUni::fgUCS4EncodingString2)
  ------------------
  |  Branch (1329:14): [True: 0, False: 7.61k]
  ------------------
 1330|  7.62k|         ||  XMLString::equals(inputEncoding, XMLUni::fgUCS4EncodingString3)
  ------------------
  |  Branch (1330:14): [True: 0, False: 7.61k]
  ------------------
 1331|  7.62k|         ||  XMLString::equals(inputEncoding, XMLUni::fgUCS4EncodingString4)
  ------------------
  |  Branch (1331:14): [True: 0, False: 7.61k]
  ------------------
 1332|  7.62k|         ||  XMLString::equals(inputEncoding, XMLUni::fgUCS4EncodingString5))
  ------------------
  |  Branch (1332:14): [True: 0, False: 7.61k]
  ------------------
 1333|      1|    {
 1334|      1|        fMemoryManager->deallocate(inputEncoding);
 1335|       |
 1336|      1|        if ((fEncoding != XMLRecognizer::UCS_4L)
  ------------------
  |  Branch (1336:13): [True: 1, False: 0]
  ------------------
 1337|      1|        &&  (fEncoding != XMLRecognizer::UCS_4B))
  ------------------
  |  Branch (1337:13): [True: 1, False: 0]
  ------------------
 1338|      1|        {
 1339|      1|            return false;
 1340|      1|        }
 1341|       |
 1342|       |        // Override with the original endian specific encoding
 1343|      0|        newBaseEncoding = fEncoding;
 1344|       |
 1345|      0|        if (fEncoding == XMLRecognizer::UCS_4L) {
  ------------------
  |  Branch (1345:13): [True: 0, False: 0]
  ------------------
 1346|       |
 1347|      0|            fMemoryManager->deallocate(fEncodingStr);
 1348|      0|            fEncodingStr = 0;
 1349|      0|            fEncodingStr = XMLString::replicate(XMLUni::fgUCS4LEncodingString, fMemoryManager);
 1350|      0|        }
 1351|      0|        else {
 1352|       |
 1353|      0|            fMemoryManager->deallocate(fEncodingStr);
 1354|      0|            fEncodingStr = 0;
 1355|      0|            fEncodingStr = XMLString::replicate(XMLUni::fgUCS4BEncodingString, fMemoryManager);
 1356|      0|        }
 1357|      0|    }
 1358|  7.61k|     else
 1359|  7.61k|    {
 1360|       |        //
 1361|       |        //  Try to map the string to one of our standard encodings. If its not
 1362|       |        //  one of them, then it has to be one of the non-intrinsic encodings,
 1363|       |        //  in which case we have to delete our intrinsic encoder and create a
 1364|       |        //  new one.
 1365|       |        //
 1366|  7.61k|        newBaseEncoding = XMLRecognizer::encodingForName(inputEncoding);
 1367|       |
 1368|       |        //
 1369|       |        //  If it does not come back as one of the auto-sensed encodings, then we
 1370|       |        //  have to possibly replace it and at least check a few things.
 1371|       |        //
 1372|  7.61k|        if (newBaseEncoding == XMLRecognizer::OtherEncoding)
  ------------------
  |  Branch (1372:13): [True: 7.43k, False: 184]
  ------------------
 1373|  7.43k|        {
 1374|       |            //
 1375|       |            // We already know it's none of those non-endian special cases,
 1376|       |            // so just replicate the new name and use it directly to create the transcoder
 1377|       |            //
 1378|  7.43k|            fMemoryManager->deallocate(fEncodingStr);
 1379|  7.43k|            fEncodingStr = inputEncoding;
 1380|       |
 1381|       |            // Check for a pre-created transcoder to delete.
 1382|  7.43k|            if (fTranscoder) {
  ------------------
  |  Branch (1382:17): [True: 0, False: 7.43k]
  ------------------
 1383|      0|                delete fTranscoder;
 1384|      0|                fTranscoder = 0;
 1385|      0|            }
 1386|       |
 1387|  7.43k|            XMLTransService::Codes failReason;
 1388|  7.43k|            fTranscoder = XMLPlatformUtils::fgTransService->makeNewTranscoderFor
 1389|  7.43k|            (
 1390|  7.43k|                fEncodingStr
 1391|  7.43k|                , failReason
 1392|  7.43k|                , kCharBufSize
 1393|  7.43k|                , fMemoryManager
 1394|  7.43k|            );
 1395|       |
 1396|  7.43k|            if (!fTranscoder)
  ------------------
  |  Branch (1396:17): [True: 94, False: 7.34k]
  ------------------
 1397|     94|                ThrowXMLwithMemMgr1(TranscodingException, XMLExcepts::Trans_CantCreateCvtrFor, fEncodingStr, fMemoryManager);
  ------------------
  |  |  266|     94|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1398|  7.43k|        }
 1399|    184|        else
 1400|    184|        {
 1401|       |            // Store the new encoding string since it is just an intrinsic
 1402|    184|            fMemoryManager->deallocate(fEncodingStr);
 1403|    184|            fEncodingStr = inputEncoding;
 1404|    184|        }
 1405|  7.61k|    }
 1406|       |
 1407|  7.52k|    if (!fTranscoder) {
  ------------------
  |  Branch (1407:9): [True: 184, False: 7.34k]
  ------------------
 1408|       |        //
 1409|       |        //  Now we can create a transcoder using the recognized fEncoding.  We
 1410|       |        //  might get back a transcoder for an intrinsically supported encoding,
 1411|       |        //  or we might get one from the underlying transcoding service.
 1412|       |        //
 1413|    184|        XMLTransService::Codes failReason;
 1414|    184|        fTranscoder = XMLPlatformUtils::fgTransService->makeNewTranscoderFor
 1415|    184|        (
 1416|    184|            newBaseEncoding
 1417|    184|            , failReason
 1418|    184|            , kCharBufSize
 1419|    184|            , fMemoryManager
 1420|    184|        );
 1421|       |
 1422|    184|        if (!fTranscoder)
  ------------------
  |  Branch (1422:13): [True: 0, False: 184]
  ------------------
 1423|      0|            ThrowXMLwithMemMgr1(TranscodingException, XMLExcepts::Trans_CantCreateCvtrFor, fEncodingStr, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1424|    184|    }
 1425|       |
 1426|       |    // Update the base encoding member with the new base encoding found
 1427|  7.52k|    fEncoding = newBaseEncoding;
 1428|       |
 1429|       |    // Looks ok to us
 1430|  7.52k|    return true;
 1431|  7.52k|}
_ZN11xercesc_3_29XMLReader15checkForSwappedEv:
 1443|  25.4k|{
 1444|       |    // Assume not swapped
 1445|  25.4k|    fSwapped = false;
 1446|       |
 1447|  25.4k|	if (XMLPlatformUtils::fgXMLChBigEndian)
  ------------------
  |  Branch (1447:6): [True: 0, False: 25.4k]
  ------------------
 1448|      0|	{
 1449|      0|        if ((fEncoding == XMLRecognizer::UTF_16L)
  ------------------
  |  Branch (1449:13): [True: 0, False: 0]
  ------------------
 1450|      0|        ||  (fEncoding == XMLRecognizer::UCS_4L))
  ------------------
  |  Branch (1450:13): [True: 0, False: 0]
  ------------------
 1451|      0|        {
 1452|      0|            fSwapped = true;
 1453|      0|        }
 1454|      0|    }
 1455|  25.4k|    else
 1456|  25.4k|    {
 1457|  25.4k|        if ((fEncoding == XMLRecognizer::UTF_16B)
  ------------------
  |  Branch (1457:13): [True: 0, False: 25.4k]
  ------------------
 1458|  25.4k|        ||  (fEncoding == XMLRecognizer::UCS_4B))
  ------------------
  |  Branch (1458:13): [True: 0, False: 25.4k]
  ------------------
 1459|      0|        {
 1460|      0|            fSwapped = true;
 1461|      0|        }
 1462|  25.4k|    }
 1463|  25.4k|}
_ZN11xercesc_3_29XMLReader12doInitDecodeEv:
 1476|  8.51k|{
 1477|  8.51k|    switch(fEncoding)
 1478|  8.51k|    {
 1479|      0|        case XMLRecognizer::UCS_4B :
  ------------------
  |  Branch (1479:9): [True: 0, False: 8.51k]
  ------------------
 1480|      0|        case XMLRecognizer::UCS_4L :
  ------------------
  |  Branch (1480:9): [True: 0, False: 8.51k]
  ------------------
 1481|      0|        {
 1482|       |            // Remove bom if any
 1483|      0|            if (((fRawByteBuf[0] == 0x00) && (fRawByteBuf[1] == 0x00) && (fRawByteBuf[2] == 0xFE) && (fRawByteBuf[3] == 0xFF)) ||
  ------------------
  |  Branch (1483:18): [True: 0, False: 0]
  |  Branch (1483:46): [True: 0, False: 0]
  |  Branch (1483:74): [True: 0, False: 0]
  |  Branch (1483:102): [True: 0, False: 0]
  ------------------
 1484|      0|                ((fRawByteBuf[0] == 0xFF) && (fRawByteBuf[1] == 0xFE) && (fRawByteBuf[2] == 0x00) && (fRawByteBuf[3] == 0x00))  )
  ------------------
  |  Branch (1484:18): [True: 0, False: 0]
  |  Branch (1484:46): [True: 0, False: 0]
  |  Branch (1484:74): [True: 0, False: 0]
  |  Branch (1484:102): [True: 0, False: 0]
  ------------------
 1485|      0|            {
 1486|      0|                for (XMLSize_t i = 0; i < fRawBytesAvail; i++)
  ------------------
  |  Branch (1486:39): [True: 0, False: 0]
  ------------------
 1487|      0|                    fRawByteBuf[i] = fRawByteBuf[i+4];
 1488|       |
 1489|      0|                fRawBytesAvail -=4;
 1490|      0|            }
 1491|       |
 1492|       |            // Look at the raw buffer as UCS4 chars
 1493|      0|            const UCS4Ch* asUCS = reinterpret_cast<const UCS4Ch*>(fRawByteBuf);
 1494|       |
 1495|      0|            while (fRawBufIndex < fRawBytesAvail)
  ------------------
  |  Branch (1495:20): [True: 0, False: 0]
  ------------------
 1496|      0|            {
 1497|       |                // Make sure there are at least sizeof(UCS4Ch) bytes to consume.
 1498|      0|                if (fRawBufIndex + sizeof(UCS4Ch) > fRawBytesAvail) {
  ------------------
  |  Branch (1498:21): [True: 0, False: 0]
  ------------------
 1499|      0|                    fCharsAvail = 0;
 1500|      0|                    fRawBufIndex = 0;
 1501|      0|                    fMemoryManager->deallocate(fPublicId);
 1502|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1503|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1504|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1505|      0|                    (
 1506|      0|                        TranscodingException
 1507|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1508|      0|                        , fSystemId
 1509|      0|                        , fMemoryManager
 1510|      0|                    );
 1511|      0|                }
 1512|       |
 1513|       |                // Make sure we don't exhaust the limited prolog buffer size.
 1514|       |                // Leave room for a space added at the end of this function.
 1515|      0|                if (fCharsAvail == kCharBufSize - 1) {
  ------------------
  |  Branch (1515:21): [True: 0, False: 0]
  ------------------
 1516|      0|                    fCharsAvail = 0;
 1517|      0|                    fRawBufIndex = 0;
 1518|      0|                    fMemoryManager->deallocate(fPublicId);
 1519|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1520|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1521|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1522|      0|                    (
 1523|      0|                        TranscodingException
 1524|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1525|      0|                        , fSystemId
 1526|      0|                        , fMemoryManager
 1527|      0|                    );
 1528|      0|                }
 1529|       |
 1530|       |                // Get out the current 4 byte value and inc our raw buf index
 1531|      0|                UCS4Ch curVal = *asUCS++;
 1532|      0|                fRawBufIndex += sizeof(UCS4Ch);
 1533|       |
 1534|       |                // Swap if that is required for this machine
 1535|      0|                if (fSwapped)
  ------------------
  |  Branch (1535:21): [True: 0, False: 0]
  ------------------
 1536|      0|                    curVal = BitOps::swapBytes(curVal);
 1537|       |
 1538|       |                // Make sure its at least semi legal. If not, undo and throw
 1539|      0|                if (curVal > 0xFFFF)
  ------------------
  |  Branch (1539:21): [True: 0, False: 0]
  ------------------
 1540|      0|                {
 1541|      0|                    fCharsAvail = 0;
 1542|      0|                    fRawBufIndex = 0;
 1543|      0|                    fMemoryManager->deallocate(fPublicId);
 1544|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1545|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1546|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1547|      0|                    (
 1548|      0|                        TranscodingException
 1549|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1550|      0|                        , fSystemId
 1551|      0|                        , fMemoryManager
 1552|      0|                    );
 1553|      0|                }
 1554|       |
 1555|       |                // Convert the value to an XML char and store it
 1556|      0|                fCharSizeBuf[fCharsAvail] = 4;
 1557|      0|                fCharBuf[fCharsAvail++] = XMLCh(curVal);
 1558|       |
 1559|       |                // Break out on the > character
 1560|      0|                if (curVal == chCloseAngle)
  ------------------
  |  Branch (1560:21): [True: 0, False: 0]
  ------------------
 1561|      0|                    break;
 1562|      0|            }
 1563|      0|            break;
 1564|      0|        }
 1565|       |
 1566|  8.51k|        case XMLRecognizer::UTF_8 :
  ------------------
  |  Branch (1566:9): [True: 8.51k, False: 0]
  ------------------
 1567|  8.51k|        {
 1568|       |            // If there's a utf-8 BOM  (0xEF 0xBB 0xBF), skip past it.
 1569|       |            //   Don't move to char buf - no one wants to see it.
 1570|       |            //   Note: this causes any encoding= declaration to override
 1571|       |            //         the BOM's attempt to say that the encoding is utf-8.
 1572|       |
 1573|       |            // Look at the raw buffer as short chars
 1574|  8.51k|            const char* asChars = (const char*)fRawByteBuf;
 1575|       |
 1576|  8.51k|            if (fRawBytesAvail > XMLRecognizer::fgUTF8BOMLen &&
  ------------------
  |  Branch (1576:17): [True: 8.51k, False: 0]
  ------------------
 1577|  8.51k|                XMLString::compareNString(  asChars
  ------------------
  |  Branch (1577:17): [True: 0, False: 8.51k]
  ------------------
 1578|  8.51k|                                            , XMLRecognizer::fgUTF8BOM
 1579|  8.51k|                                            , XMLRecognizer::fgUTF8BOMLen) == 0)
 1580|      0|            {
 1581|      0|                fRawBufIndex += XMLRecognizer::fgUTF8BOMLen;
 1582|      0|                asChars      += XMLRecognizer::fgUTF8BOMLen;
 1583|      0|            }
 1584|       |
 1585|       |            //
 1586|       |            //  First check that there are enough bytes to even see the
 1587|       |            //  decl indentifier. If not, get out now with no action since
 1588|       |            //  there is no decl.
 1589|       |            //
 1590|  8.51k|            if (fRawBytesAvail < XMLRecognizer::fgASCIIPreLen)
  ------------------
  |  Branch (1590:17): [True: 0, False: 8.51k]
  ------------------
 1591|      0|                break;
 1592|       |
 1593|       |            // Check for the opening sequence. If not, then no decl
 1594|  8.51k|            if (XMLString::compareNString(  asChars
  ------------------
  |  Branch (1594:17): [True: 0, False: 8.51k]
  ------------------
 1595|  8.51k|                                            , XMLRecognizer::fgASCIIPre
 1596|  8.51k|                                            , XMLRecognizer::fgASCIIPreLen))
 1597|      0|            {
 1598|      0|                break;
 1599|      0|            }
 1600|       |
 1601|   616k|            while (fRawBufIndex < fRawBytesAvail)
  ------------------
  |  Branch (1601:20): [True: 616k, False: 0]
  ------------------
 1602|   616k|            {
 1603|   616k|                const char curCh = *asChars++;
 1604|   616k|                fRawBufIndex++;
 1605|       |
 1606|       |                // Make sure we don't exhaust the limited prolog buffer size.
 1607|       |                // Leave room for a space added at the end of this function.
 1608|   616k|                if (fCharsAvail == kCharBufSize - 1) {
  ------------------
  |  Branch (1608:21): [True: 2, False: 616k]
  ------------------
 1609|      2|                    fCharsAvail = 0;
 1610|      2|                    fRawBufIndex = 0;
 1611|      2|                    fMemoryManager->deallocate(fPublicId);
 1612|      2|                    fMemoryManager->deallocate(fEncodingStr);
 1613|      2|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1614|      2|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      2|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1615|      2|                    (
 1616|      2|                        TranscodingException
 1617|      2|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1618|      2|                        , fSystemId
 1619|      2|                        , fMemoryManager
 1620|      2|                    );
 1621|      2|                }
 1622|       |
 1623|       |                // Looks ok, so store it
 1624|   616k|                fCharSizeBuf[fCharsAvail] = 1;
 1625|   616k|                fCharBuf[fCharsAvail++] = XMLCh(curCh);
 1626|       |
 1627|       |                // Break out on a > character
 1628|   616k|                if (curCh == chCloseAngle)
  ------------------
  |  Branch (1628:21): [True: 8.51k, False: 607k]
  ------------------
 1629|  8.51k|                    break;
 1630|       |
 1631|       |                //
 1632|       |                //  A char greater than 0x7F is not allowed in this case. If
 1633|       |                //  so, undo and throw.
 1634|       |                //
 1635|   607k|                if (curCh & 0x80)
  ------------------
  |  Branch (1635:21): [True: 0, False: 607k]
  ------------------
 1636|      0|                {
 1637|      0|                    fCharsAvail = 0;
 1638|      0|                    fRawBufIndex = 0;
 1639|      0|                    fMemoryManager->deallocate(fPublicId);
 1640|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1641|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1642|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1643|      0|                    (
 1644|      0|                        TranscodingException
 1645|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1646|      0|                        , fSystemId
 1647|      0|                        , fMemoryManager
 1648|      0|                    );
 1649|      0|                }
 1650|   607k|            }
 1651|  8.51k|            break;
 1652|  8.51k|        }
 1653|       |
 1654|  8.51k|        case XMLRecognizer::UTF_16B :
  ------------------
  |  Branch (1654:9): [True: 0, False: 8.51k]
  ------------------
 1655|      0|        case XMLRecognizer::UTF_16L :
  ------------------
  |  Branch (1655:9): [True: 0, False: 8.51k]
  ------------------
 1656|      0|        {
 1657|       |            //
 1658|       |            //  If there is a decl here, we just truncate back the characters
 1659|       |            //  as we go. No surrogate creation would be allowed here in legal
 1660|       |            //  XML, so we consider it a transoding error if we find one.
 1661|       |            //
 1662|      0|            if (fRawBytesAvail < 2)
  ------------------
  |  Branch (1662:17): [True: 0, False: 0]
  ------------------
 1663|      0|                break;
 1664|       |
 1665|      0|            XMLSize_t postBOMIndex = 0;
 1666|      0|            const UTF16Ch* asUTF16 = reinterpret_cast<const UTF16Ch*>(&fRawByteBuf[fRawBufIndex]);
 1667|      0|            if ((*asUTF16 == chUnicodeMarker) || (*asUTF16 == chSwappedUnicodeMarker))
  ------------------
  |  Branch (1667:17): [True: 0, False: 0]
  |  Branch (1667:50): [True: 0, False: 0]
  ------------------
 1668|      0|            {
 1669|      0|                fRawBufIndex += sizeof(UTF16Ch);
 1670|      0|                asUTF16++;
 1671|      0|                postBOMIndex = fRawBufIndex;
 1672|      0|            }
 1673|       |
 1674|       |            //  First check that there are enough raw bytes for there to even
 1675|       |            //  be a decl indentifier. If not, then nothing to do.
 1676|       |            //
 1677|      0|            if (fRawBytesAvail - fRawBufIndex < XMLRecognizer::fgUTF16PreLen)
  ------------------
  |  Branch (1677:17): [True: 0, False: 0]
  ------------------
 1678|      0|            {
 1679|      0|                fRawBufIndex = postBOMIndex;
 1680|      0|                break;
 1681|      0|            }
 1682|       |
 1683|       |            //
 1684|       |            //  See we get a match on the prefix. If not, then reset and
 1685|       |            //  break out.
 1686|       |            //
 1687|      0|            if (fEncoding == XMLRecognizer::UTF_16B)
  ------------------
  |  Branch (1687:17): [True: 0, False: 0]
  ------------------
 1688|      0|            {
 1689|      0|                if (memcmp(asUTF16, XMLRecognizer::fgUTF16BPre, XMLRecognizer::fgUTF16PreLen))
  ------------------
  |  Branch (1689:21): [True: 0, False: 0]
  ------------------
 1690|      0|                {
 1691|      0|                    fRawBufIndex = postBOMIndex;
 1692|      0|                    break;
 1693|      0|                }
 1694|      0|            }
 1695|      0|             else
 1696|      0|            {
 1697|      0|                if (memcmp(asUTF16, XMLRecognizer::fgUTF16LPre, XMLRecognizer::fgUTF16PreLen))
  ------------------
  |  Branch (1697:21): [True: 0, False: 0]
  ------------------
 1698|      0|                {
 1699|      0|                    fRawBufIndex = postBOMIndex;
 1700|      0|                    break;
 1701|      0|                }
 1702|      0|            }
 1703|       |
 1704|      0|            while (fRawBufIndex < fRawBytesAvail)
  ------------------
  |  Branch (1704:20): [True: 0, False: 0]
  ------------------
 1705|      0|            {
 1706|       |                // Make sure there are at least sizeof(UTF16Ch) bytes to consume.
 1707|      0|                if (fRawBufIndex + sizeof(UTF16Ch) > fRawBytesAvail) {
  ------------------
  |  Branch (1707:21): [True: 0, False: 0]
  ------------------
 1708|      0|                    fCharsAvail = 0;
 1709|      0|                    fRawBufIndex = 0;
 1710|      0|                    fMemoryManager->deallocate(fPublicId);
 1711|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1712|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1713|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1714|      0|                    (
 1715|      0|                        TranscodingException
 1716|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1717|      0|                        , fSystemId
 1718|      0|                        , fMemoryManager
 1719|      0|                    );
 1720|      0|                }
 1721|       |
 1722|       |                // Make sure we don't exhaust the limited prolog buffer size.
 1723|       |                // Leave room for a space added at the end of this function.
 1724|      0|                if (fCharsAvail == kCharBufSize - 1) {
  ------------------
  |  Branch (1724:21): [True: 0, False: 0]
  ------------------
 1725|      0|                    fCharsAvail = 0;
 1726|      0|                    fRawBufIndex = 0;
 1727|      0|                    fMemoryManager->deallocate(fPublicId);
 1728|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1729|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1730|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1731|      0|                    (
 1732|      0|                        TranscodingException
 1733|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1734|      0|                        , fSystemId
 1735|      0|                        , fMemoryManager
 1736|      0|                    );
 1737|      0|                }
 1738|       |
 1739|       |                // Get out the current 2 byte value
 1740|      0|                UTF16Ch curVal = *asUTF16++;
 1741|      0|                fRawBufIndex += sizeof(UTF16Ch);
 1742|       |
 1743|       |                // Swap if that is required for this machine
 1744|      0|                if (fSwapped)
  ------------------
  |  Branch (1744:21): [True: 0, False: 0]
  ------------------
 1745|      0|                    curVal = BitOps::swapBytes(curVal);
 1746|       |
 1747|       |                //
 1748|       |                //  Store it and bump the target index, implicitly converting
 1749|       |                //  if UTF16Ch and XMLCh are not the same size.
 1750|       |                //
 1751|      0|                fCharSizeBuf[fCharsAvail] = 2;
 1752|      0|                fCharBuf[fCharsAvail++] = curVal;
 1753|       |
 1754|       |                // Break out on a > char
 1755|      0|                if (curVal == chCloseAngle)
  ------------------
  |  Branch (1755:21): [True: 0, False: 0]
  ------------------
 1756|      0|                    break;
 1757|      0|            }
 1758|      0|            break;
 1759|      0|        }
 1760|       |
 1761|      0|        case XMLRecognizer::EBCDIC :
  ------------------
  |  Branch (1761:9): [True: 0, False: 8.51k]
  ------------------
 1762|      0|        {
 1763|       |            //
 1764|       |            //  We use special support in the intrinsic EBCDIC-US transcoder
 1765|       |            //  to go through one char at a time.
 1766|       |            //
 1767|      0|            const XMLByte* srcPtr = fRawByteBuf;
 1768|      0|            while (1)
  ------------------
  |  Branch (1768:20): [Folded - Ignored]
  ------------------
 1769|      0|            {
 1770|       |                // Transcode one char from the source
 1771|      0|                const XMLCh chCur = XMLEBCDICTranscoder::xlatThisOne(*srcPtr++);
 1772|      0|                fRawBufIndex++;
 1773|       |
 1774|       |                // Make sure we don't exhaust the limited prolog buffer size.
 1775|       |                // Leave room for a space added at the end of this function.
 1776|      0|                if (fCharsAvail == kCharBufSize - 1) {
  ------------------
  |  Branch (1776:21): [True: 0, False: 0]
  ------------------
 1777|      0|                    fCharsAvail = 0;
 1778|      0|                    fRawBufIndex = 0;
 1779|      0|                    fMemoryManager->deallocate(fPublicId);
 1780|      0|                    fMemoryManager->deallocate(fEncodingStr);
 1781|      0|                    ArrayJanitor<XMLCh> janValue(fSystemId, fMemoryManager);
 1782|      0|                    ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1783|      0|                    (
 1784|      0|                        TranscodingException
 1785|      0|                        , XMLExcepts::Reader_CouldNotDecodeFirstLine
 1786|      0|                        , fSystemId
 1787|      0|                        , fMemoryManager
 1788|      0|                    );
 1789|      0|                }
 1790|       |
 1791|       |
 1792|       |                //
 1793|       |                //  And put it into the character buffer. This stuff has to
 1794|       |                //  look like it was normally transcoded.
 1795|       |                //
 1796|      0|                fCharSizeBuf[fCharsAvail] = 1;
 1797|      0|                fCharBuf[fCharsAvail++] = chCur;
 1798|       |
 1799|       |                // If its a > char, then break out
 1800|      0|                if (chCur == chCloseAngle)
  ------------------
  |  Branch (1800:21): [True: 0, False: 0]
  ------------------
 1801|      0|                    break;
 1802|       |
 1803|       |                // Watch for using up all input and get out
 1804|      0|                if (fRawBufIndex == fRawBytesAvail)
  ------------------
  |  Branch (1804:21): [True: 0, False: 0]
  ------------------
 1805|      0|                    break;
 1806|      0|            }
 1807|      0|            break;
 1808|      0|        }
 1809|       |
 1810|      0|        default :
  ------------------
  |  Branch (1810:9): [True: 0, False: 8.51k]
  ------------------
 1811|       |            // It should never be anything else here
 1812|      0|            fMemoryManager->deallocate(fPublicId);
 1813|      0|            fMemoryManager->deallocate(fEncodingStr);
 1814|      0|            fMemoryManager->deallocate(fSystemId);
 1815|      0|            ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Reader_BadAutoEncoding, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1816|      0|            break;
 1817|  8.51k|    }
 1818|       |
 1819|       |    //
 1820|       |    //  Ok, by the time we get here, if its a legal XML file we have eaten
 1821|       |    //  the XML/TextDecl. So, if we are a PE and are being referenced from
 1822|       |    //  outside a literal, then we need to throw in an arbitrary space that
 1823|       |    //  is required by XML.
 1824|       |    //
 1825|  8.51k|    if ((fType == Type_PE) && (fRefFrom == RefFrom_NonLiteral))
  ------------------
  |  Branch (1825:9): [True: 0, False: 8.51k]
  |  Branch (1825:31): [True: 0, False: 0]
  ------------------
 1826|      0|        fCharBuf[fCharsAvail++] = chSpace;
 1827|       |
 1828|       |    //  Calculate fCharOfsBuf buffer using the elements from fCharBufSize
 1829|  8.51k|    if (fCalculateSrcOfs)
  ------------------
  |  Branch (1829:9): [True: 0, False: 8.51k]
  ------------------
 1830|      0|    {
 1831|      0|        fCharOfsBuf[0] = 0;
 1832|      0|        for (XMLSize_t index = 1; index < fCharsAvail; ++index) {
  ------------------
  |  Branch (1832:35): [True: 0, False: 0]
  ------------------
 1833|      0|            fCharOfsBuf[index] = fCharOfsBuf[index-1]+fCharSizeBuf[index-1];
 1834|      0|        }
 1835|      0|    }
 1836|  8.51k|}
_ZN11xercesc_3_29XMLReader16refreshRawBufferEv:
 1845|  64.6k|{
 1846|       |    // Make sure we don't underflow on the subtraction.
 1847|  64.6k|    if (fRawBufIndex > fRawBytesAvail) {
  ------------------
  |  Branch (1847:9): [True: 0, False: 64.6k]
  ------------------
 1848|      0|        ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1849|      0|        (
 1850|      0|            RuntimeException
 1851|      0|            , XMLExcepts::Str_StartIndexPastEnd
 1852|      0|            , fSystemId
 1853|      0|            , fMemoryManager
 1854|      0|        );
 1855|      0|    }
 1856|       |
 1857|       |    //
 1858|       |    //  If there are any bytes left, move them down to the start. There
 1859|       |    //  should only ever be (max bytes per char - 1) at the most.
 1860|       |    //
 1861|  64.6k|    const XMLSize_t bytesLeft = fRawBytesAvail - fRawBufIndex;
 1862|       |
 1863|       |    // Move the existing ones down
 1864|  1.31M|    for (XMLSize_t index = 0; index < bytesLeft; index++)
  ------------------
  |  Branch (1864:31): [True: 1.25M, False: 64.6k]
  ------------------
 1865|  1.25M|        fRawByteBuf[index] = fRawByteBuf[fRawBufIndex + index];
 1866|       |
 1867|       |    //
 1868|       |    //  And then read into the buffer past the existing bytes. Add back in
 1869|       |    //  that many to the bytes read, and subtract that many from the bytes
 1870|       |    //  requested.
 1871|       |    //
 1872|  64.6k|    fRawBytesAvail = fStream->readBytes
 1873|  64.6k|    (
 1874|  64.6k|        &fRawByteBuf[bytesLeft], kRawBufSize - bytesLeft
 1875|  64.6k|    ) + bytesLeft;
 1876|       |
 1877|       |    //
 1878|       |    //  We need to reset the buffer index back to the start in all cases,
 1879|       |    //  since any trailing data was copied down to the start.
 1880|       |    //
 1881|  64.6k|    fRawBufIndex = 0;
 1882|  64.6k|}
_ZN11xercesc_3_29XMLReader14xcodeMoreCharsEPDsPhm:
 1894|  68.3k|{
 1895|  68.3k|    XMLSize_t charsDone = 0;
 1896|  68.3k|    XMLSize_t bytesEaten = 0;
 1897|  68.3k|    bool needMode = false;
 1898|       |
 1899|   111k|    while (!bytesEaten)
  ------------------
  |  Branch (1899:12): [True: 68.4k, False: 43.2k]
  ------------------
 1900|  68.4k|    {
 1901|       |        // If our raw buffer is low, then lets load up another batch of
 1902|       |        // raw bytes now.
 1903|       |        //
 1904|  68.4k|        XMLSize_t bytesLeft = fRawBytesAvail - fRawBufIndex;
 1905|  68.4k|        if (needMode || bytesLeft == 0 || bytesLeft < fLowWaterMark)
  ------------------
  |  Branch (1905:13): [True: 79, False: 68.3k]
  |  Branch (1905:25): [True: 30.9k, False: 37.4k]
  |  Branch (1905:43): [True: 8.21k, False: 29.2k]
  ------------------
 1906|  39.2k|        {
 1907|  39.2k|            refreshRawBuffer();
 1908|       |
 1909|       |            // If there are no characters or if we need more but didn't get
 1910|       |            // any, return zero now.
 1911|       |            //
 1912|  39.2k|            if (fRawBytesAvail == 0 ||
  ------------------
  |  Branch (1912:17): [True: 25.0k, False: 14.1k]
  ------------------
 1913|  39.2k|                (needMode && (bytesLeft == fRawBytesAvail - fRawBufIndex)))
  ------------------
  |  Branch (1913:18): [True: 79, False: 14.0k]
  |  Branch (1913:30): [True: 48, False: 31]
  ------------------
 1914|  25.1k|                return 0;
 1915|  39.2k|        }
 1916|       |
 1917|       |        // Ask the transcoder to internalize another batch of chars. It is
 1918|       |        // possible that there is data in the raw buffer but the transcoder
 1919|       |        // is unable to produce anything because transcoding of multi-byte
 1920|       |        // encodings may have left a few bytes representing a partial
 1921|       |        // character in the buffer that can't be used until the next chunk
 1922|       |        // (and the rest of the character) is read. In this case set the
 1923|       |        // needMore flag and try again.
 1924|       |        //
 1925|       |
 1926|  43.2k|        charsDone = fTranscoder->transcodeFrom
 1927|  43.2k|          (
 1928|  43.2k|            &fRawByteBuf[fRawBufIndex]
 1929|  43.2k|            , fRawBytesAvail - fRawBufIndex
 1930|  43.2k|            , bufToFill
 1931|  43.2k|            , maxChars
 1932|  43.2k|            , bytesEaten
 1933|  43.2k|            , charSizes
 1934|  43.2k|          );
 1935|       |
 1936|  43.2k|        if (bytesEaten == 0)
  ------------------
  |  Branch (1936:13): [True: 79, False: 43.2k]
  ------------------
 1937|     79|            needMode = true;
 1938|  43.2k|        else
 1939|  43.2k|            fRawBufIndex += bytesEaten;
 1940|  43.2k|    }
 1941|       |
 1942|  43.2k|    return charsDone;
 1943|  68.3k|}
_ZN11xercesc_3_29XMLReader9handleEOLERDsb:
 1969|  7.94M|{
 1970|       |    // 1. the two-character sequence #xD #xA
 1971|       |    // 2. the two-character sequence #xD #x85
 1972|       |    // 5. any #xD character that is not immediately followed by #xA or #x85.
 1973|  7.94M|    switch(curCh)
 1974|  7.94M|    {
 1975|  27.1k|    case chCR:
  ------------------
  |  Branch (1975:5): [True: 27.1k, False: 7.91M]
  ------------------
 1976|  27.1k|        fCurCol = 1;
 1977|  27.1k|        fCurLine++;
 1978|       |
 1979|       |        //
 1980|       |        //  If not already internalized, then convert it to an
 1981|       |        //  LF and eat any following LF.
 1982|       |        //
 1983|  27.1k|        if (fSource == Source_External)
  ------------------
  |  Branch (1983:13): [True: 23.8k, False: 3.33k]
  ------------------
 1984|  23.8k|        {
 1985|  23.8k|            if ((fCharIndex < fCharsAvail) || refreshCharBuffer())
  ------------------
  |  Branch (1985:17): [True: 23.1k, False: 632]
  |  Branch (1985:47): [True: 630, False: 2]
  ------------------
 1986|  23.8k|            {
 1987|  23.8k|                if ( fCharBuf[fCharIndex] == chLF              ||
  ------------------
  |  Branch (1987:22): [True: 243, False: 23.5k]
  ------------------
 1988|  23.8k|                    ((fCharBuf[fCharIndex] == chNEL) && fNEL)  )
  ------------------
  |  Branch (1988:22): [True: 393, False: 23.1k]
  |  Branch (1988:57): [True: 197, False: 196]
  ------------------
 1989|    440|                {
 1990|    440|                    fCharIndex++;
 1991|    440|                }
 1992|  23.8k|            }
 1993|  23.8k|            curCh = chLF;
 1994|  23.8k|        }
 1995|  27.1k|        break;
 1996|       |
 1997|  1.24M|    case chLF:
  ------------------
  |  Branch (1997:5): [True: 1.24M, False: 6.69M]
  ------------------
 1998|  1.24M|        fCurCol = 1;
 1999|  1.24M|        fCurLine++;
 2000|  1.24M|        break;
 2001|       |
 2002|       |    // 3. the single character #x85
 2003|       |    // 4. the single character #x2028
 2004|    802|    case chNEL:
  ------------------
  |  Branch (2004:5): [True: 802, False: 7.94M]
  ------------------
 2005|    998|    case chLineSeparator:
  ------------------
  |  Branch (2005:5): [True: 196, False: 7.94M]
  ------------------
 2006|    998|        if (inDecl && fXMLVersion == XMLV1_1)
  ------------------
  |  Branch (2006:13): [True: 0, False: 998]
  |  Branch (2006:23): [True: 0, False: 0]
  ------------------
 2007|      0|        {
 2008|       |
 2009|       |        /***
 2010|       |         * XML1.1
 2011|       |         *
 2012|       |         * 2.11 End-of-Line Handling
 2013|       |         *  ...
 2014|       |         *   The characters #x85 and #x2028 cannot be reliably recognized and translated
 2015|       |         *   until an entity's encoding declaration (if present) has been read.
 2016|       |         *   Therefore, it is a fatal error to use them within the XML declaration or
 2017|       |         *   text declaration.
 2018|       |         *
 2019|       |         ***/
 2020|      0|            ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 2021|      0|                (
 2022|      0|                TranscodingException
 2023|      0|                , XMLExcepts::Reader_NelLsepinDecl
 2024|      0|                , fSystemId
 2025|      0|                , fMemoryManager
 2026|      0|                );
 2027|      0|        }
 2028|       |
 2029|    998|        if (fNEL && fSource == Source_External)
  ------------------
  |  Branch (2029:13): [True: 504, False: 494]
  |  Branch (2029:21): [True: 437, False: 67]
  ------------------
 2030|    437|        {
 2031|    437|            fCurCol = 1;
 2032|    437|            fCurLine++;
 2033|    437|            curCh = chLF;
 2034|    437|        }
 2035|    998|        break;
 2036|  6.66M|    default:
  ------------------
  |  Branch (2036:5): [True: 6.66M, False: 1.27M]
  ------------------
 2037|  6.66M|        fCurCol++;
 2038|  7.94M|    }
 2039|  7.94M|}

_ZNK11xercesc_3_29XMLReader10isNameCharEDs:
  477|  60.8M|{
  478|  60.8M|    return ((fgCharCharsTable[toCheck] & gNameCharMask) != 0);
  479|  60.8M|}
_ZNK11xercesc_3_29XMLReader15isFirstNameCharEDs:
  493|  2.65M|{
  494|  2.65M|    return ((fgCharCharsTable[toCheck] & gFirstNameCharMask) != 0);
  495|  2.65M|}
_ZNK11xercesc_3_29XMLReader21isSpecialStartTagCharEDs:
  504|  1.03M|{
  505|  1.03M|    return ((fgCharCharsTable[toCheck] & gSpecialStartTagCharMask) != 0);
  506|  1.03M|}
_ZNK11xercesc_3_29XMLReader9isXMLCharEDs:
  509|   118M|{
  510|   118M|    return ((fgCharCharsTable[toCheck] & gXMLCharMask) != 0);
  511|   118M|}
_ZNK11xercesc_3_29XMLReader12isWhitespaceEDs:
  520|  72.4M|{
  521|  72.4M|    return ((fgCharCharsTable[toCheck] & gWhitespaceCharMask) != 0);
  522|  72.4M|}
_ZNK11xercesc_3_29XMLReader13isControlCharEDs:
  525|    123|{
  526|    123|    return ((fgCharCharsTable[toCheck] & gControlCharMask) != 0);
  527|    123|}
_ZNK11xercesc_3_29XMLReader17charsLeftInBufferEv:
  533|  1.90M|{
  534|  1.90M|    return fCharsAvail - fCharIndex;
  535|  1.90M|}
_ZNK11xercesc_3_29XMLReader15getColumnNumberEv:
  542|  14.7k|{
  543|  14.7k|    return fCurCol;
  544|  14.7k|}
_ZNK11xercesc_3_29XMLReader14getEncodingStrEv:
  547|  8.50k|{
  548|  8.50k|    return fEncodingStr;
  549|  8.50k|}
_ZNK11xercesc_3_29XMLReader13getLineNumberEv:
  552|  14.7k|{
  553|  14.7k|    return fCurLine;
  554|  14.7k|}
_ZNK11xercesc_3_29XMLReader13getNoMoreFlagEv:
  557|  7.92M|{
  558|  7.92M|    return fNoMore;
  559|  7.92M|}
_ZNK11xercesc_3_29XMLReader11getPublicIdEv:
  562|  6.26k|{
  563|  6.26k|    return fPublicId;
  564|  6.26k|}
_ZNK11xercesc_3_29XMLReader12getReaderNumEv:
  567|  3.32M|{
  568|  3.32M|    return fReaderNum;
  569|  3.32M|}
_ZNK11xercesc_3_29XMLReader11getSystemIdEv:
  582|  6.26k|{
  583|  6.26k|    return fSystemId;
  584|  6.26k|}
_ZNK11xercesc_3_29XMLReader13getThrowAtEndEv:
  587|  15.8k|{
  588|  15.8k|    return fThrowAtEnd;
  589|  15.8k|}
_ZNK11xercesc_3_29XMLReader7getTypeEv:
  592|  23.9k|{
  593|  23.9k|    return fType;
  594|  23.9k|}
_ZN11xercesc_3_29XMLReader12setReaderNumEm:
  600|  25.4k|{
  601|  25.4k|    fReaderNum = newNum;
  602|  25.4k|}
_ZN11xercesc_3_29XMLReader13setXMLVersionENS0_10XMLVersionE:
  610|  33.9k|{
  611|  33.9k|    fXMLVersion = version;
  612|  33.9k|    if (version == XMLV1_1) {
  ------------------
  |  Branch (612:9): [True: 428, False: 33.4k]
  ------------------
  613|    428|        fNEL = true;
  614|    428|        fgCharCharsTable = XMLChar1_1::fgCharCharsTable1_1;
  615|    428|    }
  616|  33.4k|    else {
  617|  33.4k|        fNEL = XMLChar1_0::enableNEL;
  618|  33.4k|        fgCharCharsTable = XMLChar1_0::fgCharCharsTable1_0;
  619|  33.4k|    }
  620|       |
  621|  33.9k|}
_ZN11xercesc_3_29XMLReader21movePlainContentCharsERNS_9XMLBufferE:
  636|  1.15M|{
  637|  1.15M|    const XMLSize_t chunkSize = fCharsAvail - fCharIndex;
  638|  1.15M|    const XMLCh* cursor = &fCharBuf[fCharIndex];
  639|  1.15M|    XMLSize_t count=0;
  640|  12.4M|    for(;count<chunkSize && (fgCharCharsTable[*cursor++] & gPlainContentCharMask) != 0;++count) /*noop*/ ;
  ------------------
  |  Branch (640:10): [True: 12.3M, False: 6.44k]
  |  Branch (640:29): [True: 11.2M, False: 1.14M]
  ------------------
  641|       |
  642|  1.15M|    if (count!=0)
  ------------------
  |  Branch (642:9): [True: 425k, False: 729k]
  ------------------
  643|   425k|    {
  644|   425k|        dest.append(&fCharBuf[fCharIndex], count);
  645|   425k|        fCharIndex += count;
  646|   425k|        fCurCol    += (XMLFileLoc)count;
  647|   425k|    }
  648|  1.15M|}
_ZN11xercesc_3_29XMLReader16getNextCharIfNotEDsRDs:
  655|  2.02M|{
  656|       |    //
  657|       |    //  See if there is at least a char in the buffer. Else, do the buffer
  658|       |    //  reload logic.
  659|       |    //
  660|  2.02M|    if (fCharIndex >= fCharsAvail)
  ------------------
  |  Branch (660:9): [True: 6.49k, False: 2.01M]
  ------------------
  661|  6.49k|    {
  662|       |        // If fNoMore is set, then we have nothing else to give
  663|  6.49k|        if (fNoMore)
  ------------------
  |  Branch (663:13): [True: 266, False: 6.22k]
  ------------------
  664|    266|            return false;
  665|       |
  666|       |        // Try to refresh
  667|  6.22k|        if (!refreshCharBuffer())
  ------------------
  |  Branch (667:13): [True: 5.04k, False: 1.17k]
  ------------------
  668|  5.04k|            return false;
  669|  6.22k|    }
  670|       |
  671|       |    // Check the next char
  672|  2.01M|    if (fCharBuf[fCharIndex] == chNotToGet)
  ------------------
  |  Branch (672:9): [True: 683k, False: 1.33M]
  ------------------
  673|   683k|        return false;
  674|       |
  675|       |    // Its not the one we want to skip so bump the index
  676|  1.33M|    chGotten = fCharBuf[fCharIndex++];
  677|       |
  678|       |    // Handle end of line normalization and line/col member maintenance.
  679|       |    //
  680|       |    // we can have end-of-line combinations with a leading
  681|       |    // chCR(xD), chLF(xA), chNEL(x85), or chLineSeparator(x2028)
  682|       |    //
  683|       |    // 0000000000001101 chCR
  684|       |    // 0000000000001010 chLF
  685|       |    // 0000000010000101 chNEL
  686|       |    // 0010000000101000 chLineSeparator
  687|       |    // -----------------------
  688|       |    // 1101111101010000 == ~(chCR|chLF|chNEL|chLineSeparator)
  689|       |    //
  690|       |    // if the result of the logical-& operation is
  691|       |    // true  : 'curCh' can not be chCR, chLF, chNEL or chLineSeparator
  692|       |    // false : 'curCh' can be chCR, chLF, chNEL or chLineSeparator
  693|       |    //
  694|  1.33M|    if ( chGotten & (XMLCh) ~(chCR|chLF|chNEL|chLineSeparator) )
  ------------------
  |  Branch (694:10): [True: 875k, False: 460k]
  ------------------
  695|   875k|    {
  696|   875k|        fCurCol++;
  697|   875k|    } else
  698|   460k|    {
  699|   460k|        handleEOL(chGotten, false);
  700|   460k|    }
  701|       |
  702|  1.33M|    return true;
  703|  2.01M|}
_ZN11xercesc_3_29XMLReader11getNextCharERDs:
  709|   129M|{
  710|       |    //
  711|       |    //  See if there is at least a char in the buffer. Else, do the buffer
  712|       |    //  reload logic.
  713|       |    //
  714|   129M|    if (fCharIndex >= fCharsAvail)
  ------------------
  |  Branch (714:9): [True: 26.1k, False: 129M]
  ------------------
  715|  26.1k|    {
  716|       |        // If fNoMore is set, then we have nothing else to give
  717|  26.1k|        if (fNoMore)
  ------------------
  |  Branch (717:13): [True: 578, False: 25.5k]
  ------------------
  718|    578|            return false;
  719|       |
  720|       |        // Try to refresh
  721|  25.5k|        if (!refreshCharBuffer())
  ------------------
  |  Branch (721:13): [True: 9.47k, False: 16.0k]
  ------------------
  722|  9.47k|            return false;
  723|  25.5k|    }
  724|       |
  725|   129M|    chGotten = fCharBuf[fCharIndex++];
  726|       |
  727|       |    // Handle end of line normalization and line/col member maintenance.
  728|       |    //
  729|       |    // we can have end-of-line combinations with a leading
  730|       |    // chCR(xD), chLF(xA), chNEL(x85), or chLineSeparator(x2028)
  731|       |    //
  732|       |    // 0000000000001101 chCR
  733|       |    // 0000000000001010 chLF
  734|       |    // 0000000010000101 chNEL
  735|       |    // 0010000000101000 chLineSeparator
  736|       |    // -----------------------
  737|       |    // 1101111101010000 == ~(chCR|chLF|chNEL|chLineSeparator)
  738|       |    //
  739|       |    // if the result of the logical-& operation is
  740|       |    // true  : 'curCh' can not be chCR, chLF, chNEL or chLineSeparator
  741|       |    // false : 'curCh' can be chCR, chLF, chNEL or chLineSeparator
  742|       |    //
  743|   129M|    if ( chGotten & (XMLCh) ~(chCR|chLF|chNEL|chLineSeparator) )
  ------------------
  |  Branch (743:10): [True: 121M, False: 7.46M]
  ------------------
  744|   121M|    {
  745|   121M|        fCurCol++;
  746|   121M|    } else
  747|  7.46M|    {
  748|  7.46M|        handleEOL(chGotten, false);
  749|  7.46M|    }
  750|       |
  751|   129M|    return true;
  752|   129M|}
_ZN11xercesc_3_29XMLReader12peekNextCharERDs:
  759|  6.78M|{
  760|       |    //
  761|       |    //  If there is something still in the buffer, get it. Else do the reload
  762|       |    //  scenario.
  763|       |    //
  764|  6.78M|    if (fCharIndex >= fCharsAvail)
  ------------------
  |  Branch (764:9): [True: 16.2k, False: 6.76M]
  ------------------
  765|  16.2k|    {
  766|       |        // Try to refresh the buffer
  767|  16.2k|        if (!refreshCharBuffer())
  ------------------
  |  Branch (767:13): [True: 7.20k, False: 9.01k]
  ------------------
  768|  7.20k|        {
  769|  7.20k|            chGotten = chNull;
  770|  7.20k|            return false;
  771|  7.20k|        }
  772|  16.2k|    }
  773|       |
  774|  6.77M|    chGotten = fCharBuf[fCharIndex];
  775|       |
  776|       |    //
  777|       |    //  Even though we are only peeking, we have to act the same as the
  778|       |    //  normal char get method in regards to newline normalization, though
  779|       |    //  its not as complicated as the actual character getting method's.
  780|       |    //
  781|  6.77M|    if ((chGotten == chCR || (fNEL && (chGotten == chNEL || chGotten == chLineSeparator)))
  ------------------
  |  Branch (781:10): [True: 3.28k, False: 6.77M]
  |  Branch (781:31): [True: 2.99k, False: 6.76M]
  |  Branch (781:40): [True: 67, False: 2.93k]
  |  Branch (781:61): [True: 194, False: 2.73k]
  ------------------
  782|  6.77M|        && (fSource == Source_External))
  ------------------
  |  Branch (782:12): [True: 1.11k, False: 2.37k]
  ------------------
  783|  1.11k|        chGotten = chLF;
  784|       |
  785|  6.77M|    return true;
  786|  6.78M|}

_ZN11xercesc_3_214XMLInitializer20initializeXMLScannerEv:
   56|      1|{
   57|      1|    gMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgXMLErrDomain);
   58|       |
   59|      1|    if (!gMsgLoader)
  ------------------
  |  Branch (59:9): [True: 0, False: 1]
  ------------------
   60|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   61|       |
   62|      1|    sScannerMutex = new XMLMutex(XMLPlatformUtils::fgMemoryManager);
   63|      1|}
_ZN11xercesc_3_210XMLScannerC2EPNS_12XMLValidatorEPNS_15GrammarResolverEPNS_13MemoryManagerE:
  161|  8.51k|{
  162|  8.51k|    CleanupType cleanup(this, &XMLScanner::cleanUp);
  163|       |
  164|  8.51k|    try
  165|  8.51k|    {
  166|  8.51k|        commonInit();
  167|  8.51k|    }
  168|  8.51k|    catch(const OutOfMemoryException&)
  169|  8.51k|    {
  170|       |        // Don't cleanup when out of memory, since executing the
  171|       |        // code can cause problems.
  172|      0|        cleanup.release();
  173|       |
  174|      0|        throw;
  175|      0|    }
  176|       |
  177|  8.51k|    cleanup.release();
  178|  8.51k|}
_ZN11xercesc_3_210XMLScannerD2Ev:
  283|  8.51k|{
  284|  8.51k|    cleanUp();
  285|  8.51k|}
_ZN11xercesc_3_210XMLScanner10commonInitEv:
  686|  8.51k|{
  687|       |    //  We have to do a little init that involves statics, so we have to
  688|       |    //  use the mutex to protect it.
  689|  8.51k|    {
  690|  8.51k|        XMLMutexLock lockInit(sScannerMutex);
  691|       |
  692|       |        // And assign ourselves the next available scanner id
  693|  8.51k|        fScannerId = ++gScannerId;
  694|  8.51k|    }
  695|       |
  696|       |    //  Create the attribute list, which is used to store attribute values
  697|       |    //  during start tag processing. Give it a reasonable initial size that
  698|       |    //  will serve for most folks, though it will grow as required.
  699|  8.51k|    fAttrList = new (fMemoryManager) RefVectorOf<XMLAttr>(32, true, fMemoryManager);
  700|       |
  701|       |    //  Create the id ref list. This is used to enforce XML 1.0 ID ref
  702|       |    //  semantics, i.e. all id refs must refer to elements that exist
  703|  8.51k|    fValidationContext = new (fMemoryManager) ValidationContextImpl(fMemoryManager);
  704|  8.51k|    fValidationContext->setElemStack(&fElemStack);
  705|  8.51k|    fValidationContext->setScanner(this);
  706|       |
  707|       |    //  Create the GrammarResolver
  708|       |    //fGrammarResolver = new GrammarResolver();
  709|       |
  710|       |    // create initial, 64-element, fUIntPool
  711|  8.51k|    fUIntPool = (unsigned int **)fMemoryManager->allocate(sizeof(unsigned int *) *fUIntPoolRowTotal);
  712|  8.51k|    memset(fUIntPool, 0, sizeof(unsigned int *) * fUIntPoolRowTotal);
  713|  8.51k|    fUIntPool[0] = (unsigned int *)fMemoryManager->allocate(sizeof(unsigned int) << 6);
  714|  8.51k|    memset(fUIntPool[0], 0, sizeof(unsigned int) << 6);
  715|       |
  716|       |    // Register self as handler for XMLBufferFull events on the CDATA buffer
  717|  8.51k|    fCDataBuf.setFullHandler(this, fBufferSize);
  718|       |
  719|  8.51k|   if (fValidator) {
  ------------------
  |  Branch (719:8): [True: 0, False: 8.51k]
  ------------------
  720|      0|       fValidatorFromUser = true;
  721|      0|       initValidator(fValidator);
  722|      0|   }
  723|  8.51k|}
_ZN11xercesc_3_210XMLScanner7cleanUpEv:
  726|  8.51k|{
  727|  8.51k|    delete fAttrList;
  728|  8.51k|    delete fAttrDupChkRegistry;
  729|  8.51k|    delete fValidationContext;
  730|  8.51k|    fMemoryManager->deallocate(fRootElemName);//delete [] fRootElemName;
  731|  8.51k|    fMemoryManager->deallocate(fExternalSchemaLocation);//delete [] fExternalSchemaLocation;
  732|  8.51k|    fMemoryManager->deallocate(fExternalNoNamespaceSchemaLocation);//delete [] fExternalNoNamespaceSchemaLocation;
  733|       |    // delete fUIntPool
  734|  8.51k|    if (fUIntPool)
  ------------------
  |  Branch (734:9): [True: 8.51k, False: 0]
  ------------------
  735|  8.51k|    {
  736|  17.0k|        for (unsigned int i=0; i<=fUIntPoolRow; i++)
  ------------------
  |  Branch (736:32): [True: 8.51k, False: 8.51k]
  ------------------
  737|  8.51k|        {
  738|  8.51k|            fMemoryManager->deallocate(fUIntPool[i]);
  739|  8.51k|        }
  740|  8.51k|        fMemoryManager->deallocate(fUIntPool);
  741|  8.51k|    }
  742|  8.51k|}
_ZN11xercesc_3_210XMLScanner13initValidatorEPNS_12XMLValidatorE:
  744|  17.0k|void XMLScanner::initValidator(XMLValidator* theValidator) {
  745|       |
  746|       |    //  Tell the validator about the stuff it needs to know in order to
  747|       |    //  do its work.
  748|  17.0k|    theValidator->setScannerInfo(this, &fReaderMgr, &fBufMgr);
  749|  17.0k|    theValidator->setErrorReporter(fErrorReporter);
  750|  17.0k|}
_ZN11xercesc_3_210XMLScanner27emitErrorWillThrowExceptionENS_7XMLErrs5CodesE:
  760|  47.5k|{
  761|  47.5k|    if (XMLErrs::isFatal(toEmit) && fExitOnFirstFatal && !fInException)
  ------------------
  |  Branch (761:9): [True: 8.24k, False: 39.3k]
  |  Branch (761:37): [True: 8.24k, False: 0]
  |  Branch (761:58): [True: 5.29k, False: 2.95k]
  ------------------
  762|  5.29k|        return true;
  763|  42.2k|    return false;
  764|  47.5k|}
_ZN11xercesc_3_210XMLScanner9emitErrorENS_7XMLErrs5CodesE:
  767|  3.37k|{
  768|       |    // Bump the error count if it is not a warning
  769|  3.37k|    if (XMLErrs::errorType(toEmit) != XMLErrorReporter::ErrType_Warning)
  ------------------
  |  Branch (769:9): [True: 3.37k, False: 0]
  ------------------
  770|  3.37k|        incrementErrorCount();
  771|       |
  772|  3.37k|    if (fErrorReporter)
  ------------------
  |  Branch (772:9): [True: 0, False: 3.37k]
  ------------------
  773|      0|    {
  774|       |        // Load the message into a local for display
  775|      0|        const XMLSize_t msgSize = 1023;
  776|      0|        XMLCh errText[msgSize + 1];
  777|       |
  778|      0|        if (!gMsgLoader->loadMsg(toEmit, errText, msgSize))
  ------------------
  |  Branch (778:13): [True: 0, False: 0]
  ------------------
  779|      0|        {
  780|       |                // <TBD> Probably should load a default msg here
  781|      0|        }
  782|       |
  783|       |        //  Create a LastExtEntityInfo structure and get the reader manager
  784|       |        //  to fill it in for us. This will give us the information about
  785|       |        //  the last reader on the stack that was an external entity of some
  786|       |        //  sort (i.e. it will ignore internal entities.
  787|      0|        ReaderMgr::LastExtEntityInfo lastInfo;
  788|      0|        fReaderMgr.getLastExtEntityInfo(lastInfo);
  789|       |
  790|      0|        fErrorReporter->error
  791|      0|        (
  792|      0|            toEmit
  793|      0|            , XMLUni::fgXMLErrDomain
  794|      0|            , XMLErrs::errorType(toEmit)
  795|      0|            , errText
  796|      0|            , lastInfo.systemId
  797|      0|            , lastInfo.publicId
  798|      0|            , lastInfo.lineNumber
  799|      0|            , lastInfo.colNumber
  800|      0|        );
  801|      0|    }
  802|       |
  803|       |    // Bail out if its fatal an we are to give up on the first fatal error
  804|  3.37k|    if (emitErrorWillThrowException(toEmit))
  ------------------
  |  Branch (804:9): [True: 3.37k, False: 0]
  ------------------
  805|  3.37k|        throw toEmit;
  806|  3.37k|}
_ZN11xercesc_3_210XMLScanner9emitErrorENS_7XMLErrs5CodesEPKDsS4_S4_S4_:
  813|  41.2k|{
  814|       |    // Bump the error count if it is not a warning
  815|  41.2k|    if (XMLErrs::errorType(toEmit) != XMLErrorReporter::ErrType_Warning)
  ------------------
  |  Branch (815:9): [True: 1.92k, False: 39.3k]
  ------------------
  816|  1.92k|        incrementErrorCount();
  817|       |
  818|  41.2k|    if (fErrorReporter)
  ------------------
  |  Branch (818:9): [True: 0, False: 41.2k]
  ------------------
  819|      0|    {
  820|       |        //  Load the message into alocal and replace any tokens found in
  821|       |        //  the text.
  822|      0|        const XMLSize_t maxChars = 2047;
  823|      0|        XMLCh errText[maxChars + 1];
  824|       |
  825|      0|        if (!gMsgLoader->loadMsg(toEmit, errText, maxChars, text1, text2, text3, text4, fMemoryManager))
  ------------------
  |  Branch (825:13): [True: 0, False: 0]
  ------------------
  826|      0|        {
  827|       |                // <TBD> Should probably load a default message here
  828|      0|        }
  829|       |
  830|       |        //  Create a LastExtEntityInfo structure and get the reader manager
  831|       |        //  to fill it in for us. This will give us the information about
  832|       |        //  the last reader on the stack that was an external entity of some
  833|       |        //  sort (i.e. it will ignore internal entities.
  834|      0|        ReaderMgr::LastExtEntityInfo lastInfo;
  835|      0|        fReaderMgr.getLastExtEntityInfo(lastInfo);
  836|       |
  837|      0|        fErrorReporter->error
  838|      0|        (
  839|      0|            toEmit
  840|      0|            , XMLUni::fgXMLErrDomain
  841|      0|            , XMLErrs::errorType(toEmit)
  842|      0|            , errText
  843|      0|            , lastInfo.systemId
  844|      0|            , lastInfo.publicId
  845|      0|            , lastInfo.lineNumber
  846|      0|            , lastInfo.colNumber
  847|      0|        );
  848|      0|    }
  849|       |
  850|       |    // Bail out if its fatal an we are to give up on the first fatal error
  851|  41.2k|    if (emitErrorWillThrowException(toEmit))
  ------------------
  |  Branch (851:9): [True: 1.92k, False: 39.3k]
  ------------------
  852|  1.92k|        throw toEmit;
  853|  41.2k|}
_ZN11xercesc_3_210XMLScanner9emitErrorENS_7XMLErrs5CodesENS_10XMLExcepts5CodesEPKDsS6_S6_S6_:
  908|  2.95k|{
  909|       |    // Bump the error count if it is not a warning
  910|  2.95k|    if (XMLErrs::errorType(toEmit) != XMLErrorReporter::ErrType_Warning)
  ------------------
  |  Branch (910:9): [True: 2.95k, False: 0]
  ------------------
  911|  2.95k|        incrementErrorCount();
  912|       |
  913|  2.95k|    if (fErrorReporter)
  ------------------
  |  Branch (913:9): [True: 0, False: 2.95k]
  ------------------
  914|      0|    {
  915|       |        //  Load the message into alocal and replace any tokens found in
  916|       |        //  the text.
  917|      0|        const XMLSize_t maxChars = 2047;
  918|      0|        XMLCh errText[maxChars + 1];
  919|       |
  920|      0|        if (!gMsgLoader->loadMsg(toEmit, errText, maxChars, text1, text2, text3, text4, fMemoryManager))
  ------------------
  |  Branch (920:13): [True: 0, False: 0]
  ------------------
  921|      0|        {
  922|       |                // <TBD> Should probably load a default message here
  923|      0|        }
  924|       |
  925|       |        //  Create a LastExtEntityInfo structure and get the reader manager
  926|       |        //  to fill it in for us. This will give us the information about
  927|       |        //  the last reader on the stack that was an external entity of some
  928|       |        //  sort (i.e. it will ignore internal entities.
  929|      0|        ReaderMgr::LastExtEntityInfo lastInfo;
  930|      0|        fReaderMgr.getLastExtEntityInfo(lastInfo);
  931|       |
  932|      0|        fErrorReporter->error
  933|      0|        (
  934|      0|            originalExceptCode
  935|      0|            , XMLUni::fgExceptDomain    //fgXMLErrDomain
  936|      0|            , XMLErrs::errorType(toEmit)
  937|      0|            , errText
  938|      0|            , lastInfo.systemId
  939|      0|            , lastInfo.publicId
  940|      0|            , lastInfo.lineNumber
  941|      0|            , lastInfo.colNumber
  942|      0|        );
  943|      0|    }
  944|       |
  945|       |    // Bail out if its fatal an we are to give up on the first fatal error
  946|  2.95k|    if (emitErrorWillThrowException(toEmit))
  ------------------
  |  Branch (946:9): [True: 0, False: 2.95k]
  ------------------
  947|      0|        throw toEmit;
  948|  2.95k|}
_ZN11xercesc_3_210XMLScanner17scanMiscellaneousEv:
 1005|  1.42k|{
 1006|       |    // Get a buffer for this work
 1007|  1.42k|    XMLBufBid bbCData(&fBufMgr);
 1008|       |
 1009|  3.71k|    while (true)
  ------------------
  |  Branch (1009:12): [Folded - Ignored]
  ------------------
 1010|  3.71k|    {
 1011|  3.71k|        try
 1012|  3.71k|        {
 1013|  3.71k|            const XMLCh nextCh = fReaderMgr.peekNextChar();
 1014|       |
 1015|       |            // Watch for end of file and break out
 1016|  3.71k|            if (!nextCh)
  ------------------
  |  Branch (1016:17): [True: 271, False: 3.43k]
  ------------------
 1017|    271|                break;
 1018|       |
 1019|  3.43k|            if (nextCh == chOpenAngle)
  ------------------
  |  Branch (1019:17): [True: 1.98k, False: 1.45k]
  ------------------
 1020|  1.98k|            {
 1021|  1.98k|                if (checkXMLDecl(true))
  ------------------
  |  Branch (1021:21): [True: 1, False: 1.98k]
  ------------------
 1022|      1|                {
 1023|       |                    // Can't have an XML decl here
 1024|      1|                    emitError(XMLErrs::NotValidAfterContent);
 1025|      1|                    fReaderMgr.skipPastChar(chCloseAngle);
 1026|      1|                }
 1027|  1.98k|                else if (fReaderMgr.skippedString(XMLUni::fgPIString))
  ------------------
  |  Branch (1027:26): [True: 1.64k, False: 333]
  ------------------
 1028|  1.64k|                {
 1029|  1.64k|                    scanPI();
 1030|  1.64k|                }
 1031|    333|                 else if (fReaderMgr.skippedString(XMLUni::fgCommentString))
  ------------------
  |  Branch (1031:27): [True: 260, False: 73]
  ------------------
 1032|    260|                {
 1033|    260|                    scanComment();
 1034|    260|                }
 1035|     73|                else
 1036|     73|                {
 1037|       |                    // This can't be possible, so just give up
 1038|     73|                    emitError(XMLErrs::ExpectedCommentOrPI);
 1039|     73|                    fReaderMgr.skipPastChar(chCloseAngle);
 1040|     73|                }
 1041|  1.98k|            }
 1042|  1.45k|            else if (fReaderMgr.getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (1042:22): [True: 436, False: 1.02k]
  ------------------
 1043|    436|            {
 1044|       |                //  If we have a doc handler, then gather up the spaces and
 1045|       |                //  call back. Otherwise, just skip over whitespace.
 1046|    436|                if (fDocHandler)
  ------------------
  |  Branch (1046:21): [True: 0, False: 436]
  ------------------
 1047|      0|                {
 1048|      0|                    fReaderMgr.getSpaces(bbCData.getBuffer());
 1049|      0|                    fDocHandler->ignorableWhitespace
 1050|      0|                    (
 1051|      0|                        bbCData.getRawBuffer()
 1052|      0|                        , bbCData.getLen()
 1053|      0|                        , false
 1054|      0|                    );
 1055|      0|                }
 1056|    436|                else
 1057|    436|                {
 1058|    436|                    fReaderMgr.skipPastSpaces();
 1059|    436|                }
 1060|    436|            }
 1061|  1.02k|            else
 1062|  1.02k|            {
 1063|  1.02k|                emitError(XMLErrs::ExpectedCommentOrPI);
 1064|  1.02k|                fReaderMgr.skipPastChar(chCloseAngle);
 1065|  1.02k|            }
 1066|  3.43k|        }
 1067|  3.71k|        catch(const EndOfEntityException&)
 1068|  3.71k|        {
 1069|       |            //  Some entity leaked out of the content part of the document. Issue
 1070|       |            //  a warning and keep going.
 1071|      0|            emitError(XMLErrs::EntityPropogated);
 1072|      0|        }
 1073|  3.71k|    }
 1074|  1.42k|}
_ZN11xercesc_3_210XMLScanner6scanPIEv:
 1080|  9.18k|{
 1081|  9.18k|    const XMLCh* namePtr = 0;
 1082|  9.18k|    const XMLCh* targetPtr = 0;
 1083|       |
 1084|       |    //  If there are any spaces here, then warn about it. If we aren't in
 1085|       |    //  'first error' mode, then we'll come back and can easily pick up
 1086|       |    //  again by just skipping them.
 1087|  9.18k|    if (fReaderMgr.lookingAtSpace())
  ------------------
  |  Branch (1087:9): [True: 3, False: 9.17k]
  ------------------
 1088|      3|    {
 1089|      3|        emitError(XMLErrs::PINameExpected);
 1090|      3|        fReaderMgr.skipPastSpaces();
 1091|      3|    }
 1092|       |
 1093|       |    // Get a buffer for the PI name and scan it in
 1094|  9.18k|    XMLBufBid bbName(&fBufMgr);
 1095|  9.18k|    if (!fReaderMgr.getName(bbName.getBuffer()))
  ------------------
  |  Branch (1095:9): [True: 7, False: 9.17k]
  ------------------
 1096|      7|    {
 1097|      7|        emitError(XMLErrs::PINameExpected);
 1098|      7|        fReaderMgr.skipPastChar(chCloseAngle);
 1099|      7|        return;
 1100|      7|    }
 1101|       |
 1102|       |    // Point the name pointer at the raw data
 1103|  9.17k|    namePtr = bbName.getRawBuffer();
 1104|       |
 1105|       |    // See if it is some form of 'xml' and emit a warning
 1106|       |    //if (!XMLString::compareIString(namePtr, XMLUni::fgXMLString))
 1107|  9.17k|    if (bbName.getLen() == 3 &&
  ------------------
  |  Branch (1107:9): [True: 5.22k, False: 3.95k]
  ------------------
 1108|  9.17k|        (((namePtr[0] == chLatin_x) || (namePtr[0] == chLatin_X)) &&
  ------------------
  |  Branch (1108:11): [True: 3.10k, False: 2.12k]
  |  Branch (1108:40): [True: 1.61k, False: 505]
  ------------------
 1109|  5.22k|         ((namePtr[1] == chLatin_m) || (namePtr[1] == chLatin_M)) &&
  ------------------
  |  Branch (1109:11): [True: 2.90k, False: 1.81k]
  |  Branch (1109:40): [True: 1.34k, False: 472]
  ------------------
 1110|  5.22k|         ((namePtr[2] == chLatin_l) || (namePtr[2] == chLatin_L))))
  ------------------
  |  Branch (1110:11): [True: 1, False: 4.24k]
  |  Branch (1110:40): [True: 1, False: 4.24k]
  ------------------
 1111|      2|        emitError(XMLErrs::NoPIStartsWithXML);
 1112|       |
 1113|       |    // If namespaces are enabled, then no colons allowed
 1114|  9.17k|    if (fDoNamespaces)
  ------------------
  |  Branch (1114:9): [True: 0, False: 9.17k]
  ------------------
 1115|      0|    {
 1116|      0|        if (XMLString::indexOf(namePtr, chColon) != -1)
  ------------------
  |  Branch (1116:13): [True: 0, False: 0]
  ------------------
 1117|      0|            emitError(XMLErrs::ColonNotLegalWithNS);
 1118|      0|    }
 1119|       |
 1120|       |    //  If we don't hit a space next, then the PI has no target. If we do
 1121|       |    //  then get out the target. Get a buffer for it as well
 1122|  9.17k|    XMLBufBid bbTarget(&fBufMgr);
 1123|  9.17k|    if (fReaderMgr.skippedSpace())
  ------------------
  |  Branch (1123:9): [True: 5.46k, False: 3.71k]
  ------------------
 1124|  5.46k|    {
 1125|       |        // Skip any leading spaces
 1126|  5.46k|        fReaderMgr.skipPastSpaces();
 1127|       |
 1128|  5.46k|        bool gotLeadingSurrogate = false;
 1129|       |
 1130|       |        // It does have a target, so lets move on to deal with that.
 1131|  2.93M|        while (1)
  ------------------
  |  Branch (1131:16): [Folded - Ignored]
  ------------------
 1132|  2.93M|        {
 1133|  2.93M|            const XMLCh nextCh = fReaderMgr.getNextChar();
 1134|       |
 1135|       |            // Watch for an end of file, which is always bad here
 1136|  2.93M|            if (!nextCh)
  ------------------
  |  Branch (1136:17): [True: 123, False: 2.93M]
  ------------------
 1137|    123|            {
 1138|    123|                emitError(XMLErrs::UnterminatedPI);
 1139|    123|                ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|    123|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1140|    123|            }
 1141|       |
 1142|       |            // Watch for potential terminating character
 1143|  2.93M|            if (nextCh == chQuestion)
  ------------------
  |  Branch (1143:17): [True: 10.9k, False: 2.91M]
  ------------------
 1144|  10.9k|            {
 1145|       |                // It must be followed by '>' to be a termination of the target
 1146|  10.9k|                if (fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (1146:21): [True: 5.30k, False: 5.60k]
  ------------------
 1147|  5.30k|                    break;
 1148|  10.9k|            }
 1149|       |
 1150|       |            // Check for correct surrogate pairs
 1151|  2.92M|            if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (1151:17): [True: 1.02k, False: 2.92M]
  |  Branch (1151:39): [True: 408, False: 618]
  ------------------
 1152|    408|            {
 1153|    408|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (1153:21): [True: 0, False: 408]
  ------------------
 1154|      0|                    emitError(XMLErrs::Expected2ndSurrogateChar);
 1155|    408|                else
 1156|    408|                    gotLeadingSurrogate = true;
 1157|    408|            }
 1158|  2.92M|             else
 1159|  2.92M|            {
 1160|  2.92M|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (1160:21): [True: 408, False: 2.92M]
  ------------------
 1161|    408|                {
 1162|    408|                    if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
  ------------------
  |  Branch (1162:25): [True: 0, False: 408]
  |  Branch (1162:46): [True: 0, False: 408]
  ------------------
 1163|      0|                        emitError(XMLErrs::Expected2ndSurrogateChar);
 1164|    408|                }
 1165|       |                // Its got to at least be a valid XML character
 1166|  2.92M|                else if (!fReaderMgr.getCurrentReader()->isXMLChar(nextCh)) {
  ------------------
  |  Branch (1166:26): [True: 8, False: 2.92M]
  ------------------
 1167|       |
 1168|      8|                    XMLCh tmpBuf[9];
 1169|      8|                    XMLString::binToText
 1170|      8|                    (
 1171|      8|                        nextCh
 1172|      8|                        , tmpBuf
 1173|      8|                        , 8
 1174|      8|                        , 16
 1175|      8|                        , fMemoryManager
 1176|      8|                    );
 1177|      8|                    emitError(XMLErrs::InvalidCharacter, tmpBuf);
 1178|      8|                }
 1179|       |
 1180|  2.92M|                gotLeadingSurrogate = false;
 1181|  2.92M|            }
 1182|       |
 1183|  2.92M|            bbTarget.append(nextCh);
 1184|  2.92M|        }
 1185|  5.46k|    }
 1186|  3.71k|    else
 1187|  3.71k|    {
 1188|       |        // No target, but make sure its terminated ok
 1189|  3.71k|        if (!fReaderMgr.skippedChar(chQuestion))
  ------------------
  |  Branch (1189:13): [True: 24, False: 3.68k]
  ------------------
 1190|     24|        {
 1191|     24|            emitError(XMLErrs::UnterminatedPI);
 1192|     24|            fReaderMgr.skipPastChar(chCloseAngle);
 1193|     24|            return;
 1194|     24|        }
 1195|       |
 1196|  3.68k|        if (!fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (1196:13): [True: 8, False: 3.68k]
  ------------------
 1197|      8|        {
 1198|      8|            emitError(XMLErrs::UnterminatedPI);
 1199|      8|            fReaderMgr.skipPastChar(chCloseAngle);
 1200|      8|            return;
 1201|      8|        }
 1202|  3.68k|    }
 1203|       |
 1204|       |    // Point the target pointer at the raw data
 1205|  9.01k|    targetPtr = bbTarget.getRawBuffer();
 1206|       |
 1207|       |    // If we have a handler, then call it
 1208|  9.01k|    if (fDocHandler)
  ------------------
  |  Branch (1208:9): [True: 0, False: 9.01k]
  ------------------
 1209|      0|    {
 1210|      0|        fDocHandler->docPI
 1211|      0|        (
 1212|      0|            namePtr
 1213|      0|            , targetPtr
 1214|      0|       );
 1215|      0|    }
 1216|       |
 1217|       |    //mark PI is seen within the current element
 1218|  9.01k|    if (! fElemStack.isEmpty())
  ------------------
  |  Branch (1218:9): [True: 6.30k, False: 2.71k]
  ------------------
 1219|  6.30k|        fElemStack.setCommentOrPISeen();
 1220|       |
 1221|  9.01k|}
_ZN11xercesc_3_210XMLScanner10scanPrologEv:
 1230|  8.51k|{
 1231|  8.51k|    bool sawDocTypeDecl = false;
 1232|       |    // Get a buffer for whitespace processing
 1233|  8.51k|    XMLBufBid bbCData(&fBufMgr);
 1234|       |
 1235|       |    //  Loop through the prolog. If there is no content, this could go all
 1236|       |    //  the way to the end of the file.
 1237|  8.51k|    try
 1238|  8.51k|    {
 1239|  38.1k|        while (true)
  ------------------
  |  Branch (1239:16): [Folded - Ignored]
  ------------------
 1240|  33.5k|        {
 1241|  33.5k|            const XMLCh nextCh = fReaderMgr.peekNextChar();
 1242|       |
 1243|  33.5k|            if (nextCh == chOpenAngle)
  ------------------
  |  Branch (1243:17): [True: 22.3k, False: 11.2k]
  ------------------
 1244|  22.3k|            {
 1245|       |                //  Ok, it could be the xml decl, a comment, the doc type line,
 1246|       |                //  or the start of the root element.
 1247|  22.3k|                if (checkXMLDecl(true))
  ------------------
  |  Branch (1247:21): [True: 8.52k, False: 13.8k]
  ------------------
 1248|  8.52k|                {
 1249|       |                    // There shall be at lease --ONE-- space in between
 1250|       |                    // the tag '<?xml' and the VersionInfo.
 1251|       |                    //
 1252|       |                    //  If we are not at line 1, col 6, then the decl was not
 1253|       |                    //  the first text, so its invalid.
 1254|  8.52k|                    const XMLReader* curReader = fReaderMgr.getCurrentReader();
 1255|  8.52k|                    if ((curReader->getLineNumber() != 1)
  ------------------
  |  Branch (1255:25): [True: 6, False: 8.51k]
  ------------------
 1256|  8.52k|                    ||  (curReader->getColumnNumber() != 7))
  ------------------
  |  Branch (1256:25): [True: 0, False: 8.51k]
  ------------------
 1257|      6|                    {
 1258|      6|                        emitError(XMLErrs::XMLDeclMustBeFirst);
 1259|      6|                    }
 1260|       |
 1261|  8.52k|                    scanXMLDecl(Decl_XML);
 1262|  8.52k|                }
 1263|  13.8k|                else if (fReaderMgr.skippedString(XMLUni::fgPIString))
  ------------------
  |  Branch (1263:26): [True: 1.14k, False: 12.6k]
  ------------------
 1264|  1.14k|                {
 1265|  1.14k|                    scanPI();
 1266|  1.14k|                }
 1267|  12.6k|                 else if (fReaderMgr.skippedString(XMLUni::fgCommentString))
  ------------------
  |  Branch (1267:27): [True: 452, False: 12.2k]
  ------------------
 1268|    452|                {
 1269|    452|                    scanComment();
 1270|    452|                }
 1271|  12.2k|                 else if (fReaderMgr.skippedString(XMLUni::fgDocTypeString))
  ------------------
  |  Branch (1271:27): [True: 8.31k, False: 3.89k]
  ------------------
 1272|  8.31k|                {
 1273|  8.31k|                    if (sawDocTypeDecl) {
  ------------------
  |  Branch (1273:25): [True: 0, False: 8.31k]
  ------------------
 1274|      0|                        emitError(XMLErrs::DuplicateDocTypeDecl);
 1275|      0|                    }
 1276|       |
 1277|  8.31k|                    const char* envvar = getenv("XERCES_DISABLE_DTD");
 1278|  8.31k|                    if (fDisallowDTD || (envvar && !strcmp(envvar, "1"))) {
  ------------------
  |  Branch (1278:25): [True: 0, False: 8.31k]
  |  Branch (1278:42): [True: 0, False: 8.31k]
  |  Branch (1278:52): [True: 0, False: 0]
  ------------------
 1279|      0|                    	emitError(XMLErrs::InvalidDocumentStructure);
 1280|      0|                    }
 1281|  8.31k|                    else {
 1282|  8.31k|                    	scanDocTypeDecl();
 1283|  8.31k|                    	sawDocTypeDecl = true;
 1284|  8.31k|                    }
 1285|       |
 1286|       |                    // if reusing grammar, this has been validated already in first scan
 1287|       |                    // skip for performance
 1288|  8.31k|                    if (fValidate && fGrammar && !fGrammar->getValidated()) {
  ------------------
  |  Branch (1288:25): [True: 4.22k, False: 4.09k]
  |  Branch (1288:38): [True: 4.22k, False: 0]
  |  Branch (1288:50): [True: 4.22k, False: 0]
  ------------------
 1289|       |                        //  validate the DTD scan so far
 1290|  4.22k|                        fValidator->preContentValidation(fUseCachedGrammar, true);
 1291|  4.22k|                    }
 1292|  8.31k|                }
 1293|  3.89k|                else
 1294|  3.89k|                {
 1295|       |                    // Assume its the start of the root element
 1296|  3.89k|                    return;
 1297|  3.89k|                }
 1298|  22.3k|            }
 1299|  11.2k|            else if (fReaderMgr.getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (1299:22): [True: 10.9k, False: 320]
  ------------------
 1300|  10.9k|            {
 1301|       |                //  If we have a document handler then gather up the
 1302|       |                //  whitespace and call back. Otherwise just skip over spaces.
 1303|  10.9k|                if (fDocHandler)
  ------------------
  |  Branch (1303:21): [True: 0, False: 10.9k]
  ------------------
 1304|      0|                {
 1305|      0|                    fReaderMgr.getSpaces(bbCData.getBuffer());
 1306|      0|                    fDocHandler->ignorableWhitespace
 1307|      0|                    (
 1308|      0|                        bbCData.getRawBuffer()
 1309|      0|                        , bbCData.getLen()
 1310|      0|                        , false
 1311|      0|                    );
 1312|      0|                }
 1313|  10.9k|                 else
 1314|  10.9k|                {
 1315|  10.9k|                    fReaderMgr.skipPastSpaces();
 1316|  10.9k|                }
 1317|  10.9k|            }
 1318|    320|             else
 1319|    320|            {
 1320|    320|                emitError(XMLErrs::InvalidDocumentStructure);
 1321|       |
 1322|       |                // Watch for end of file and break out
 1323|    320|                if (!nextCh)
  ------------------
  |  Branch (1323:21): [True: 0, False: 320]
  ------------------
 1324|      0|                    break;
 1325|    320|                else
 1326|    320|                    fReaderMgr.skipPastChar(chCloseAngle);
 1327|    320|            }
 1328|       |
 1329|  33.5k|        }
 1330|  8.51k|    }
 1331|  8.51k|    catch(const EndOfEntityException&)
 1332|  8.51k|    {
 1333|       |        //  We should never get an end of entity here. They should only
 1334|       |        //  occur within the doc type scanning method, and not leak out to
 1335|       |        //  here.
 1336|      0|        emitError
 1337|      0|        (
 1338|      0|            XMLErrs::UnexpectedEOE
 1339|      0|            , "in prolog"
 1340|      0|        );
 1341|      0|    }
 1342|  8.51k|}
_ZN11xercesc_3_210XMLScanner11scanXMLDeclENS0_9DeclTypesE:
 1360|  8.51k|{
 1361|       |    // Get us some buffers to use
 1362|  8.51k|    XMLBufBid bbVersion(&fBufMgr);
 1363|  8.51k|    XMLBufBid bbEncoding(&fBufMgr);
 1364|  8.51k|    XMLBufBid bbStand(&fBufMgr);
 1365|  8.51k|    XMLBufBid bbDummy(&fBufMgr);
 1366|  8.51k|    XMLBufBid bbName(&fBufMgr);
 1367|       |
 1368|       |    //  We use this little enum and array to keep up with what we found
 1369|       |    //  and what order we found them in. This lets us get them free form
 1370|       |    //  without too much overhead, but still know that they were in the
 1371|       |    //  wrong order.
 1372|  8.51k|    enum Strings
 1373|  8.51k|    {
 1374|  8.51k|        VersionString
 1375|  8.51k|        , EncodingString
 1376|  8.51k|        , StandaloneString
 1377|  8.51k|        , UnknownString
 1378|       |
 1379|  8.51k|        , StringCount
 1380|  8.51k|    };
 1381|  8.51k|    int flags[StringCount] = { -1, -1, -1, -1 };
 1382|       |
 1383|       |    //  Also set up a list of buffers in the right order so that we know
 1384|       |    //  where to put stuff.
 1385|  8.51k|    XMLBuffer* buffers[StringCount] ;
 1386|  8.51k|    buffers[0] = &bbVersion.getBuffer();
 1387|  8.51k|    buffers[1] = &bbEncoding.getBuffer();
 1388|  8.51k|    buffers[2] = &bbStand.getBuffer();
 1389|  8.51k|    buffers[3] = &bbDummy.getBuffer();
 1390|       |
 1391|  8.51k|    int curCount = 0;
 1392|  8.51k|    Strings curString;
 1393|  8.51k|    XMLBuffer& nameBuf = bbName.getBuffer();
 1394|  33.1k|    while (true)
  ------------------
  |  Branch (1394:12): [Folded - Ignored]
  ------------------
 1395|  33.1k|    {
 1396|       |        // Skip any spaces
 1397|  33.1k|        bool skippedSomething;
 1398|  33.1k|        fReaderMgr.skipPastSpaces(skippedSomething, true);
 1399|       |
 1400|       |        // If we are looking at a question mark, then break out
 1401|  33.1k|        if (fReaderMgr.lookingAtChar(chQuestion))
  ------------------
  |  Branch (1401:13): [True: 8.50k, False: 24.6k]
  ------------------
 1402|  8.50k|            break;
 1403|       |
 1404|       |        // If this is not the first string, then we require the spaces
 1405|  24.6k|        if (!skippedSomething && curCount)
  ------------------
  |  Branch (1405:13): [True: 8.51k, False: 16.1k]
  |  Branch (1405:34): [True: 0, False: 8.51k]
  ------------------
 1406|      0|            emitError(XMLErrs::ExpectedWhitespace);
 1407|       |
 1408|       |        //  Get characters up to the next whitespace or equal's sign.
 1409|  24.6k|        if (!scanUpToWSOr(nameBuf, chEqual))
  ------------------
  |  Branch (1409:13): [True: 0, False: 24.6k]
  ------------------
 1410|      0|            emitError(XMLErrs::ExpectedDeclString);
 1411|       |
 1412|       |        // See if it matches any of our expected strings
 1413|  24.6k|        if (XMLString::equals(nameBuf.getRawBuffer(), XMLUni::fgVersionString))
  ------------------
  |  Branch (1413:13): [True: 8.51k, False: 16.1k]
  ------------------
 1414|  8.51k|            curString = VersionString;
 1415|  16.1k|        else if (XMLString::equals(nameBuf.getRawBuffer(), XMLUni::fgEncodingString))
  ------------------
  |  Branch (1415:18): [True: 7.65k, False: 8.47k]
  ------------------
 1416|  7.65k|            curString = EncodingString;
 1417|  8.47k|        else if (XMLString::equals(nameBuf.getRawBuffer(), XMLUni::fgStandaloneString))
  ------------------
  |  Branch (1417:18): [True: 8.47k, False: 0]
  ------------------
 1418|  8.47k|            curString = StandaloneString;
 1419|      0|        else
 1420|      0|            curString = UnknownString;
 1421|       |
 1422|       |        //  If its an unknown string, then give that error. Else check to
 1423|       |        //  see if this one has been done already and give that error.
 1424|  24.6k|        if (curString == UnknownString)
  ------------------
  |  Branch (1424:13): [True: 0, False: 24.6k]
  ------------------
 1425|      0|            emitError(XMLErrs::ExpectedDeclString, nameBuf.getRawBuffer());
 1426|  24.6k|        else if (flags[curString] != -1)
  ------------------
  |  Branch (1426:18): [True: 0, False: 24.6k]
  ------------------
 1427|      0|            emitError(XMLErrs::DeclStringRep, nameBuf.getRawBuffer());
 1428|  24.6k|        else if (flags[curString] == -1)
  ------------------
  |  Branch (1428:18): [True: 24.6k, False: 0]
  ------------------
 1429|  24.6k|            flags[curString] = ++curCount;
 1430|       |
 1431|       |        //  Scan for an equal's sign. If we don't find it, issue an error
 1432|       |        //  but keep trying to go on.
 1433|  24.6k|        if (!scanEq(true))
  ------------------
  |  Branch (1433:13): [True: 0, False: 24.6k]
  ------------------
 1434|      0|            emitError(XMLErrs::ExpectedEqSign);
 1435|       |
 1436|       |        //  Get a quote string into the buffer for the string that we are
 1437|       |        //  currently working on.
 1438|  24.6k|        if (!getQuotedString(*buffers[curString]))
  ------------------
  |  Branch (1438:13): [True: 3, False: 24.6k]
  ------------------
 1439|      3|        {
 1440|      3|            emitError(XMLErrs::ExpectedQuotedString);
 1441|      3|            fReaderMgr.skipPastChar(chCloseAngle);
 1442|      3|            return;
 1443|      3|        }
 1444|       |
 1445|       |        // And validate the value according which one it was
 1446|  24.6k|        const XMLCh* rawValue = buffers[curString]->getRawBuffer();
 1447|  24.6k|        if (curString == VersionString)
  ------------------
  |  Branch (1447:13): [True: 8.51k, False: 16.1k]
  ------------------
 1448|  8.51k|        {
 1449|  8.51k|            if (XMLString::equals(rawValue, XMLUni::fgVersion1_1)) {
  ------------------
  |  Branch (1449:17): [True: 134, False: 8.37k]
  ------------------
 1450|    134|                if (type == Decl_XML) {
  ------------------
  |  Branch (1450:21): [True: 134, False: 0]
  ------------------
 1451|    134|                    fXMLVersion = XMLReader::XMLV1_1;
 1452|    134|                    fReaderMgr.setXMLVersion(XMLReader::XMLV1_1);
 1453|    134|                }
 1454|      0|                else {
 1455|      0|                    if (fXMLVersion != XMLReader::XMLV1_1)
  ------------------
  |  Branch (1455:25): [True: 0, False: 0]
  ------------------
 1456|      0|                        emitError(XMLErrs::UnsupportedXMLVersion, rawValue);
 1457|      0|                }
 1458|    134|            }
 1459|  8.37k|            else if (XMLString::equals(rawValue, XMLUni::fgVersion1_0)) {
  ------------------
  |  Branch (1459:22): [True: 8.36k, False: 8]
  ------------------
 1460|  8.36k|                if (type == Decl_XML) {
  ------------------
  |  Branch (1460:21): [True: 8.36k, False: 0]
  ------------------
 1461|  8.36k|                    fXMLVersion = XMLReader::XMLV1_0;
 1462|  8.36k|                    fReaderMgr.setXMLVersion(XMLReader::XMLV1_0);
 1463|  8.36k|                }
 1464|  8.36k|            }
 1465|      8|            else if (XMLString::startsWith(rawValue, XMLUni::fgVersion1)) {
  ------------------
  |  Branch (1465:22): [True: 1, False: 7]
  ------------------
 1466|      1|                if (type == Decl_XML) {
  ------------------
  |  Branch (1466:21): [True: 1, False: 0]
  ------------------
 1467|      1|                    fXMLVersion = XMLReader::XMLV1_0;
 1468|      1|                    fReaderMgr.setXMLVersion(XMLReader::XMLV1_0);
 1469|      1|                }
 1470|      1|            }
 1471|      7|            else
 1472|      7|                emitError(XMLErrs::UnsupportedXMLVersion, rawValue);
 1473|  8.51k|        }
 1474|  16.1k|         else if (curString == EncodingString)
  ------------------
  |  Branch (1474:19): [True: 7.65k, False: 8.47k]
  ------------------
 1475|  7.65k|        {
 1476|  7.65k|            if (!XMLString::isValidEncName(rawValue))
  ------------------
  |  Branch (1476:17): [True: 4, False: 7.64k]
  ------------------
 1477|      4|                emitError(XMLErrs::BadXMLEncoding, rawValue);
 1478|  7.65k|        }
 1479|  8.47k|         else if (curString == StandaloneString)
  ------------------
  |  Branch (1479:19): [True: 8.47k, False: 0]
  ------------------
 1480|  8.47k|        {
 1481|  8.47k|            if (XMLString::equals(rawValue, XMLUni::fgYesString))
  ------------------
  |  Branch (1481:17): [True: 8.18k, False: 288]
  ------------------
 1482|  8.18k|                fStandalone = true;
 1483|    288|            else if (XMLString::equals(rawValue, XMLUni::fgNoString))
  ------------------
  |  Branch (1483:22): [True: 288, False: 0]
  ------------------
 1484|    288|                fStandalone = false;
 1485|      0|            else
 1486|      0|            {
 1487|      0|                emitError(XMLErrs::BadStandalone);
 1488|       |                //if (!XMLString::compareIString(rawValue, XMLUni::fgYesString))
 1489|       |                //else if (!XMLString::compareIString(rawValue, XMLUni::fgNoString))
 1490|      0|                if (buffers[curString]->getLen() == 3 &&
  ------------------
  |  Branch (1490:21): [True: 0, False: 0]
  ------------------
 1491|      0|                    (((rawValue[0] == chLatin_y) || (rawValue[0] == chLatin_Y)) &&
  ------------------
  |  Branch (1491:23): [True: 0, False: 0]
  |  Branch (1491:53): [True: 0, False: 0]
  ------------------
 1492|      0|                     ((rawValue[1] == chLatin_e) || (rawValue[1] == chLatin_E)) &&
  ------------------
  |  Branch (1492:23): [True: 0, False: 0]
  |  Branch (1492:53): [True: 0, False: 0]
  ------------------
 1493|      0|                     ((rawValue[2] == chLatin_s) || (rawValue[2] == chLatin_S))))
  ------------------
  |  Branch (1493:23): [True: 0, False: 0]
  |  Branch (1493:53): [True: 0, False: 0]
  ------------------
 1494|      0|                    fStandalone = true;
 1495|      0|                else if (buffers[curString]->getLen() == 2 &&
  ------------------
  |  Branch (1495:26): [True: 0, False: 0]
  ------------------
 1496|      0|                    (((rawValue[0] == chLatin_n) || (rawValue[0] == chLatin_N)) &&
  ------------------
  |  Branch (1496:23): [True: 0, False: 0]
  |  Branch (1496:53): [True: 0, False: 0]
  ------------------
 1497|      0|                     ((rawValue[1] == chLatin_o) || (rawValue[1] == chLatin_O))))
  ------------------
  |  Branch (1497:23): [True: 0, False: 0]
  |  Branch (1497:53): [True: 0, False: 0]
  ------------------
 1498|      0|                    fStandalone = false;
 1499|      0|            }
 1500|  8.47k|        }
 1501|  24.6k|    }
 1502|       |
 1503|       |    //  Make sure that the strings present are in order. We don't care about
 1504|       |    //  which ones are present at this point, just that any there are in the
 1505|       |    //  right order.
 1506|  8.51k|    int curTop = 0;
 1507|  25.5k|    for (int index = VersionString; index < StandaloneString; index++)
  ------------------
  |  Branch (1507:37): [True: 17.0k, False: 8.51k]
  ------------------
 1508|  17.0k|    {
 1509|  17.0k|        if (flags[index] != -1)
  ------------------
  |  Branch (1509:13): [True: 16.1k, False: 854]
  ------------------
 1510|  16.1k|        {
 1511|  16.1k|            if (flags[index] !=  curTop + 1)
  ------------------
  |  Branch (1511:17): [True: 0, False: 16.1k]
  ------------------
 1512|      0|            {
 1513|      0|                emitError(XMLErrs::DeclStringsInWrongOrder);
 1514|      0|                break;
 1515|      0|            }
 1516|  16.1k|            curTop = flags[index];
 1517|  16.1k|        }
 1518|  17.0k|    }
 1519|       |
 1520|       |    //  If its an XML decl, the version must be present.
 1521|       |    //  If its a Text decl, then encoding must be present AND standalone must not be present.
 1522|  8.51k|    if ((type == Decl_XML) && (flags[VersionString] == -1))
  ------------------
  |  Branch (1522:9): [True: 8.50k, False: 11]
  |  Branch (1522:31): [True: 0, False: 8.50k]
  ------------------
 1523|      0|        emitError(XMLErrs::XMLVersionRequired);
 1524|  8.51k|    else if (type == Decl_Text) {
  ------------------
  |  Branch (1524:14): [True: 0, False: 8.51k]
  ------------------
 1525|      0|        if (flags[StandaloneString] != -1)
  ------------------
  |  Branch (1525:13): [True: 0, False: 0]
  ------------------
 1526|      0|            emitError(XMLErrs::StandaloneNotLegal);
 1527|      0|        if (flags[EncodingString] == -1)
  ------------------
  |  Branch (1527:13): [True: 0, False: 0]
  ------------------
 1528|      0|            emitError(XMLErrs::EncodingRequired);
 1529|      0|    }
 1530|       |
 1531|  8.51k|    if (!fReaderMgr.skippedChar(chQuestion))
  ------------------
  |  Branch (1531:9): [True: 0, False: 8.51k]
  ------------------
 1532|      0|    {
 1533|      0|        emitError(XMLErrs::UnterminatedXMLDecl);
 1534|      0|        fReaderMgr.skipPastChar(chCloseAngle);
 1535|      0|    }
 1536|  8.51k|     else if (!fReaderMgr.skippedChar(chCloseAngle))
  ------------------
  |  Branch (1536:15): [True: 0, False: 8.51k]
  ------------------
 1537|      0|    {
 1538|      0|        emitError(XMLErrs::UnterminatedXMLDecl);
 1539|      0|        fReaderMgr.skipPastChar(chCloseAngle);
 1540|      0|    }
 1541|       |
 1542|       |    //  Do this before we possibly update the reader with the
 1543|       |    //  actual encoding string. Otherwise, we will pass the wrong thing
 1544|       |    //  for the last parameter!
 1545|  8.51k|    const XMLCh* actualEnc = fReaderMgr.getCurrentEncodingStr();
 1546|       |
 1547|       |    //  Ok, we've now seen the real encoding string, if there was one, so
 1548|       |    //  lets call back on the current reader and tell it what the real
 1549|       |    //  encoding string was. If it fails, that's because it represents some
 1550|       |    //  sort of contradiction with the autosensed format, and it keeps the
 1551|       |    //  original encoding.
 1552|       |    //
 1553|       |    //  NOTE: This can fail for a number of reasons, such as a bogus encoding
 1554|       |    //  name or because its in flagrant contradiction of the auto-sensed
 1555|       |    //  format.
 1556|  8.51k|    if (flags[EncodingString] != -1)
  ------------------
  |  Branch (1556:9): [True: 7.64k, False: 865]
  ------------------
 1557|  7.64k|    {
 1558|  7.64k|        if (!fReaderMgr.getCurrentReader()->setEncoding(bbEncoding.getRawBuffer()))
  ------------------
  |  Branch (1558:13): [True: 27, False: 7.61k]
  ------------------
 1559|     27|            emitError(XMLErrs::ContradictoryEncoding, bbEncoding.getRawBuffer());
 1560|  7.61k|        else
 1561|  7.61k|            actualEnc = bbEncoding.getRawBuffer();
 1562|  7.64k|    }
 1563|       |
 1564|       |    //  If we have a document handler then call the XML Decl callback.
 1565|  8.51k|    if (type == Decl_XML)
  ------------------
  |  Branch (1565:9): [True: 8.40k, False: 105]
  ------------------
 1566|  8.40k|    {
 1567|  8.40k|        if (fDocHandler)
  ------------------
  |  Branch (1567:13): [True: 0, False: 8.40k]
  ------------------
 1568|      0|            fDocHandler->XMLDecl
 1569|      0|            (
 1570|      0|                bbVersion.getRawBuffer()
 1571|      0|                , bbEncoding.getRawBuffer()
 1572|      0|                , bbStand.getRawBuffer()
 1573|      0|                , actualEnc
 1574|      0|            );
 1575|  8.40k|    }
 1576|    105|    else if (type == Decl_Text)
  ------------------
  |  Branch (1576:14): [True: 0, False: 105]
  ------------------
 1577|      0|    {
 1578|      0|        if (fDocTypeHandler)
  ------------------
  |  Branch (1578:13): [True: 0, False: 0]
  ------------------
 1579|      0|            fDocTypeHandler->TextDecl
 1580|      0|            (
 1581|      0|                bbVersion.getRawBuffer()
 1582|      0|                , bbEncoding.getRawBuffer()
 1583|      0|            );
 1584|      0|    }
 1585|  8.51k|}
_ZN11xercesc_3_210XMLScanner12checkXMLDeclEb:
 1617|  39.6k|bool XMLScanner::checkXMLDecl(bool startWithAngle) {
 1618|       |
 1619|       |    // [23] XMLDecl     ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'
 1620|       |    // [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
 1621|       |    //
 1622|       |    // [3]  S           ::= (#x20 | #x9 | #xD | #xA)+
 1623|  39.6k|    if (startWithAngle) {
  ------------------
  |  Branch (1623:9): [True: 34.2k, False: 5.35k]
  ------------------
 1624|  34.2k|        if (fReaderMgr.peekString(XMLUni::fgXMLDeclString)) {
  ------------------
  |  Branch (1624:13): [True: 8.73k, False: 25.5k]
  ------------------
 1625|  8.73k|            if (fReaderMgr.skippedString(XMLUni::fgXMLDeclStringSpace)
  ------------------
  |  Branch (1625:17): [True: 8.51k, False: 220]
  ------------------
 1626|  8.73k|               || fReaderMgr.skippedString(XMLUni::fgXMLDeclStringHTab)
  ------------------
  |  Branch (1626:19): [True: 1, False: 219]
  ------------------
 1627|  8.73k|               || fReaderMgr.skippedString(XMLUni::fgXMLDeclStringLF)
  ------------------
  |  Branch (1627:19): [True: 1, False: 218]
  ------------------
 1628|  8.73k|               || fReaderMgr.skippedString(XMLUni::fgXMLDeclStringCR))
  ------------------
  |  Branch (1628:19): [True: 1, False: 217]
  ------------------
 1629|  8.52k|            {
 1630|  8.52k|                return true;
 1631|  8.52k|            }
 1632|  8.73k|        }
 1633|  25.5k|        else if (fReaderMgr.skippedString(XMLUni::fgXMLDeclStringSpaceU)
  ------------------
  |  Branch (1633:18): [True: 12, False: 25.4k]
  ------------------
 1634|  25.5k|           || fReaderMgr.skippedString(XMLUni::fgXMLDeclStringHTabU)
  ------------------
  |  Branch (1634:15): [True: 1, False: 25.4k]
  ------------------
 1635|  25.5k|           || fReaderMgr.skippedString(XMLUni::fgXMLDeclStringLFU)
  ------------------
  |  Branch (1635:15): [True: 1, False: 25.4k]
  ------------------
 1636|  25.5k|           || fReaderMgr.skippedString(XMLUni::fgXMLDeclStringCRU))
  ------------------
  |  Branch (1636:15): [True: 1, False: 25.4k]
  ------------------
 1637|      4|        {
 1638|       |            //  Just in case, check for upper case. If found, issue
 1639|       |            //  an error, but keep going.
 1640|      4|            emitError(XMLErrs::XMLDeclMustBeLowerCase);
 1641|      4|            return true;
 1642|      4|        }
 1643|  34.2k|    }
 1644|  5.35k|    else {
 1645|  5.35k|        if (fReaderMgr.peekString(XMLUni::fgXMLString)) {
  ------------------
  |  Branch (1645:13): [True: 230, False: 5.12k]
  ------------------
 1646|    230|            if (fReaderMgr.skippedString(XMLUni::fgXMLStringSpace)
  ------------------
  |  Branch (1646:17): [True: 1, False: 229]
  ------------------
 1647|    230|               || fReaderMgr.skippedString(XMLUni::fgXMLStringHTab)
  ------------------
  |  Branch (1647:19): [True: 1, False: 228]
  ------------------
 1648|    230|               || fReaderMgr.skippedString(XMLUni::fgXMLStringLF)
  ------------------
  |  Branch (1648:19): [True: 1, False: 227]
  ------------------
 1649|    230|               || fReaderMgr.skippedString(XMLUni::fgXMLStringCR))
  ------------------
  |  Branch (1649:19): [True: 1, False: 226]
  ------------------
 1650|      4|            {
 1651|      4|                return true;
 1652|      4|            }
 1653|    230|        }
 1654|  5.12k|        else if (fReaderMgr.skippedString(XMLUni::fgXMLStringSpaceU)
  ------------------
  |  Branch (1654:18): [True: 4, False: 5.11k]
  ------------------
 1655|  5.12k|           || fReaderMgr.skippedString(XMLUni::fgXMLStringHTabU)
  ------------------
  |  Branch (1655:15): [True: 1, False: 5.11k]
  ------------------
 1656|  5.12k|           || fReaderMgr.skippedString(XMLUni::fgXMLStringLFU)
  ------------------
  |  Branch (1656:15): [True: 1, False: 5.11k]
  ------------------
 1657|  5.12k|           || fReaderMgr.skippedString(XMLUni::fgXMLStringCRU))
  ------------------
  |  Branch (1657:15): [True: 1, False: 5.11k]
  ------------------
 1658|      4|        {
 1659|       |            //  Just in case, check for upper case. If found, issue
 1660|       |            //  an error, but keep going.
 1661|      4|            emitError(XMLErrs::XMLDeclMustBeLowerCase);
 1662|      4|            return true;
 1663|      4|        }
 1664|  5.35k|    }
 1665|       |
 1666|  31.0k|    return false;
 1667|  39.6k|}
_ZN11xercesc_3_210XMLScanner16setURIStringPoolEPNS_13XMLStringPoolE:
 1806|  8.51k|{
 1807|  8.51k|    fURIStringPool = stringPool;
 1808|  8.51k|    fEmptyNamespaceId   = fURIStringPool->addOrFind(XMLUni::fgZeroLenString);
 1809|  8.51k|    fUnknownNamespaceId = fURIStringPool->addOrFind(XMLUni::fgUnknownURIName);
 1810|  8.51k|    fXMLNamespaceId     = fURIStringPool->addOrFind(XMLUni::fgXMLURIName);
 1811|  8.51k|    fXMLNSNamespaceId   = fURIStringPool->addOrFind(XMLUni::fgXMLNSURIName);
 1812|  8.51k|}
_ZN11xercesc_3_210XMLScanner16checkInternalDTDEbPKDsS2_:
 1832|  8.28k|{
 1833|  8.28k|    if (fToCacheGrammar)
  ------------------
  |  Branch (1833:9): [True: 0, False: 8.28k]
  ------------------
 1834|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Val_CantHaveIntSS, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1835|       |
 1836|  8.28k|    if (fUseCachedGrammar && hasExtSubset && !fIgnoreCachedDTD)
  ------------------
  |  Branch (1836:9): [True: 0, False: 8.28k]
  |  Branch (1836:30): [True: 0, False: 0]
  |  Branch (1836:46): [True: 0, False: 0]
  ------------------
 1837|      0|    {
 1838|      0|        InputSource* sysIdSrc = resolveSystemId(sysId, pubId);
 1839|      0|        if (sysIdSrc) {
  ------------------
  |  Branch (1839:13): [True: 0, False: 0]
  ------------------
 1840|      0|            Janitor<InputSource> janSysIdSrc(sysIdSrc);
 1841|      0|            Grammar* grammar = fGrammarResolver->getGrammar(sysIdSrc->getSystemId());
 1842|       |
 1843|      0|            if (grammar && grammar->getGrammarType() == Grammar::DTDGrammarType)
  ------------------
  |  Branch (1843:17): [True: 0, False: 0]
  |  Branch (1843:28): [True: 0, False: 0]
  ------------------
 1844|      0|            {
 1845|      0|                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Val_CantHaveIntSS, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1846|      0|            }
 1847|      0|        }
 1848|      0|    }
 1849|       |
 1850|  8.28k|}
_ZN11xercesc_3_210XMLScanner11checkIDRefsEv:
 1857|  1.42k|{
 1858|       |    //  Iterate the id ref list. If we find any entries here which are used
 1859|       |    //  but not declared, then that's an error.
 1860|  1.42k|    RefHashTableOfEnumerator<XMLRefInfo> refEnum(fValidationContext->getIdRefList(), false, fMemoryManager);
 1861|  2.53k|    while (refEnum.hasMoreElements())
  ------------------
  |  Branch (1861:12): [True: 1.10k, False: 1.42k]
  ------------------
 1862|  1.10k|    {
 1863|       |        // Get a ref to the current element
 1864|  1.10k|        const XMLRefInfo& curRef = refEnum.nextElement();
 1865|       |
 1866|       |        // If its used but not declared, then its an error
 1867|  1.10k|        if (!curRef.getDeclared() && curRef.getUsed() && fValidate)
  ------------------
  |  Branch (1867:13): [True: 1.06k, False: 38]
  |  Branch (1867:38): [True: 615, False: 450]
  |  Branch (1867:58): [True: 615, False: 0]
  ------------------
 1868|    615|            fValidator->emitError(XMLValid::IDNotDeclared, curRef.getRefName());
 1869|  1.10k|    }
 1870|  1.42k|}
_ZN11xercesc_3_210XMLScanner14senseNextTokenERm:
 1887|  1.39M|{
 1888|       |    //  Get the next character and use it to guesstimate what the next token
 1889|       |    //  is going to be. We turn on end of entity exceptions when we do this
 1890|       |    //  in order to catch the scenario where the current entity ended at
 1891|       |    //  the > of some markup.
 1892|  1.39M|    XMLCh nextCh=0;
 1893|       |
 1894|  1.39M|    XMLReader* curReader=fReaderMgr.getCurrentReader();
 1895|       |    // avoid setting up the ThrowEOEJanitor if we know that we have data in the current reader
 1896|  1.39M|    if(curReader && curReader->charsLeftInBuffer()>0)
  ------------------
  |  Branch (1896:8): [True: 1.39M, False: 0]
  |  Branch (1896:21): [True: 1.39M, False: 7.02k]
  ------------------
 1897|  1.39M|        nextCh = fReaderMgr.peekNextChar();
 1898|  7.02k|    else
 1899|  7.02k|    {
 1900|  7.02k|        ThrowEOEJanitor janMgr(&fReaderMgr, true);
 1901|  7.02k|        nextCh = fReaderMgr.peekNextChar();
 1902|  7.02k|    }
 1903|       |
 1904|       |    //  If it's not a '<' we must be in content (unless it's a EOF)
 1905|       |    //
 1906|       |    //  This includes entity references '&' of some sort. These must
 1907|       |    //  be character data because that's the only place a reference can
 1908|       |    //  occur in content.
 1909|  1.39M|    if (nextCh != chOpenAngle)
  ------------------
  |  Branch (1909:9): [True: 690k, False: 708k]
  ------------------
 1910|   690k|        return nextCh?Token_CharData:Token_EOF;
  ------------------
  |  Branch (1910:16): [True: 688k, False: 1.23k]
  ------------------
 1911|       |
 1912|       |    //  Ok it had to have been a '<' character. So get it out of the reader
 1913|       |    //  and store the reader number where we saw it, passing it back to the
 1914|       |    //  caller.
 1915|   708k|    fReaderMgr.getNextChar();
 1916|   708k|    orgReader = fReaderMgr.getCurrentReaderNum();
 1917|       |
 1918|       |    //  Ok, so lets go through the things that it could be at this point which
 1919|       |    //  are all some form of markup.
 1920|   708k|    switch(fReaderMgr.peekNextChar())
  ------------------
  |  Branch (1920:12): [True: 564k, False: 144k]
  ------------------
 1921|   708k|    {
 1922|   136k|    case chForwardSlash:
  ------------------
  |  Branch (1922:5): [True: 136k, False: 572k]
  ------------------
 1923|   136k|        {
 1924|   136k|            fReaderMgr.getNextChar();
 1925|   136k|            return Token_EndTag;
 1926|      0|        }
 1927|  1.71k|    case chBang:
  ------------------
  |  Branch (1927:5): [True: 1.71k, False: 706k]
  ------------------
 1928|  1.71k|        {
 1929|  1.71k|            static const XMLCh gCDATAStr[] =
 1930|  1.71k|            {
 1931|  1.71k|                    chBang, chOpenSquare, chLatin_C, chLatin_D, chLatin_A
 1932|  1.71k|                ,   chLatin_T, chLatin_A, chNull
 1933|  1.71k|            };
 1934|       |
 1935|  1.71k|            static const XMLCh gCommentString[] =
 1936|  1.71k|            {
 1937|  1.71k|                chBang, chDash, chDash, chNull
 1938|  1.71k|            };
 1939|       |
 1940|  1.71k|            if (fReaderMgr.skippedString(gCDATAStr))
  ------------------
  |  Branch (1940:17): [True: 1.37k, False: 336]
  ------------------
 1941|  1.37k|                return Token_CData;
 1942|       |
 1943|    336|            if (fReaderMgr.skippedString(gCommentString))
  ------------------
  |  Branch (1943:17): [True: 302, False: 34]
  ------------------
 1944|    302|                return Token_Comment;
 1945|       |
 1946|     34|            emitError(XMLErrs::ExpectedCommentOrCDATA);
 1947|     34|            return Token_Unknown;
 1948|    336|        }
 1949|  6.39k|    case chQuestion:
  ------------------
  |  Branch (1949:5): [True: 6.39k, False: 702k]
  ------------------
 1950|  6.39k|        {
 1951|       |            // It must be a PI
 1952|  6.39k|            fReaderMgr.getNextChar();
 1953|  6.39k|            return Token_PI;
 1954|    336|        }
 1955|   708k|    }
 1956|       |    //  Assume its an element name, so return with a start tag token. If it
 1957|       |    //  turns out not to be, then it will fail when it cannot get a valid tag.
 1958|   558k|    return Token_StartTag;
 1959|   708k|}
_ZN11xercesc_3_210XMLScanner15getQuotedStringERNS_9XMLBufferE:
 1974|  24.6k|{
 1975|       |    // Reset the target buffer
 1976|  24.6k|    toFill.reset();
 1977|       |
 1978|       |    // Get the next char which must be a single or double quote
 1979|  24.6k|    XMLCh quoteCh;
 1980|  24.6k|    if (!fReaderMgr.skipIfQuote(quoteCh))
  ------------------
  |  Branch (1980:9): [True: 3, False: 24.6k]
  ------------------
 1981|      3|        return false;
 1982|       |
 1983|  24.6k|	XMLCh nextCh;
 1984|       |    // Get another char and see if it matches the starting quote char
 1985|   244k|    while ((nextCh=fReaderMgr.getNextChar())!=quoteCh)
  ------------------
  |  Branch (1985:12): [True: 219k, False: 24.6k]
  ------------------
 1986|   219k|    {
 1987|       |        //  We should never get either an end of file null char here. If we
 1988|       |        //  do, just fail. It will be handled more gracefully in the higher
 1989|       |        //  level code that called us.
 1990|   219k|        if (!nextCh)
  ------------------
  |  Branch (1990:13): [True: 0, False: 219k]
  ------------------
 1991|      0|            return false;
 1992|       |
 1993|       |        // Else add it to the buffer
 1994|   219k|        toFill.append(nextCh);
 1995|   219k|    }
 1996|  24.6k|    return true;
 1997|  24.6k|}
_ZN11xercesc_3_210XMLScanner11scanCharRefERDsS1_:
 2004|  9.74k|{
 2005|  9.74k|    bool gotOne = false;
 2006|  9.74k|    unsigned int value = 0;
 2007|       |
 2008|       |    //  Set the radix. Its supposed to be a lower case x if hex. But, in
 2009|       |    //  order to recover well, we check for an upper and put out an error
 2010|       |    //  for that.
 2011|  9.74k|    unsigned int radix = 10;
 2012|  9.74k|    if (fReaderMgr.skippedChar(chLatin_x))
  ------------------
  |  Branch (2012:9): [True: 1.46k, False: 8.28k]
  ------------------
 2013|  1.46k|    {
 2014|  1.46k|        radix = 16;
 2015|  1.46k|    }
 2016|  8.28k|    else if (fReaderMgr.skippedChar(chLatin_X))
  ------------------
  |  Branch (2016:14): [True: 1, False: 8.28k]
  ------------------
 2017|      1|    {
 2018|      1|        emitError(XMLErrs::HexRadixMustBeLowerCase);
 2019|      1|        radix = 16;
 2020|      1|    }
 2021|       |
 2022|  23.5k|    while (true)
  ------------------
  |  Branch (2022:12): [Folded - Ignored]
  ------------------
 2023|  23.5k|    {
 2024|  23.5k|        const XMLCh nextCh = fReaderMgr.peekNextChar();
 2025|       |
 2026|       |        // Watch for EOF
 2027|  23.5k|        if (!nextCh)
  ------------------
  |  Branch (2027:13): [True: 2, False: 23.5k]
  ------------------
 2028|      2|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      2|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 2029|       |
 2030|       |        // Break out on the terminating semicolon
 2031|  23.5k|        if (nextCh == chSemiColon)
  ------------------
  |  Branch (2031:13): [True: 9.68k, False: 13.8k]
  ------------------
 2032|  9.68k|        {
 2033|  9.68k|            fReaderMgr.getNextChar();
 2034|  9.68k|            break;
 2035|  9.68k|        }
 2036|       |
 2037|       |        //  Convert this char to a binary value, or bail out if its not
 2038|       |        //  one.
 2039|  13.8k|        unsigned int nextVal;
 2040|  13.8k|        if ((nextCh >= chDigit_0) && (nextCh <= chDigit_9))
  ------------------
  |  Branch (2040:13): [True: 13.8k, False: 12]
  |  Branch (2040:38): [True: 12.2k, False: 1.62k]
  ------------------
 2041|  12.2k|            nextVal = (unsigned int)(nextCh - chDigit_0);
 2042|  1.63k|        else if ((nextCh >= chLatin_A) && (nextCh <= chLatin_F))
  ------------------
  |  Branch (2042:18): [True: 1.61k, False: 17]
  |  Branch (2042:43): [True: 615, False: 1.00k]
  ------------------
 2043|    615|            nextVal= (unsigned int)(10 + (nextCh - chLatin_A));
 2044|  1.01k|        else if ((nextCh >= chLatin_a) && (nextCh <= chLatin_f))
  ------------------
  |  Branch (2044:18): [True: 995, False: 23]
  |  Branch (2044:43): [True: 966, False: 29]
  ------------------
 2045|    966|            nextVal = (unsigned int)(10 + (nextCh - chLatin_a));
 2046|     52|        else
 2047|     52|        {
 2048|       |            // Return a zero
 2049|     52|            toFill = 0;
 2050|       |
 2051|       |            //  If we got at least a sigit, then do an unterminated ref error.
 2052|       |            //  Else, do an expected a numerical ref thing.
 2053|     52|            if (gotOne)
  ------------------
  |  Branch (2053:17): [True: 24, False: 28]
  ------------------
 2054|     24|                emitError(XMLErrs::UnterminatedCharRef);
 2055|     28|            else
 2056|     28|                emitError(XMLErrs::ExpectedNumericalCharRef);
 2057|       |
 2058|       |            // Return failure
 2059|     52|            return false;
 2060|     52|        }
 2061|       |
 2062|       |        //  Make sure its valid for the radix. If not, then just eat the
 2063|       |        //  digit and go on after issueing an error. Else, update the
 2064|       |        //  running value with this new digit.
 2065|  13.7k|        if (nextVal >= radix)
  ------------------
  |  Branch (2065:13): [True: 4, False: 13.7k]
  ------------------
 2066|      4|        {
 2067|      4|            XMLCh tmpStr[2];
 2068|      4|            tmpStr[0] = nextCh;
 2069|      4|            tmpStr[1] = chNull;
 2070|      4|            emitError(XMLErrs::BadDigitForRadix, tmpStr);
 2071|      4|        }
 2072|  13.7k|        else
 2073|  13.7k|        {
 2074|  13.7k|            value = (value * radix) + nextVal;
 2075|       |            // Guard against overflow.
 2076|  13.7k|            if (value > 0x10FFFF) {
  ------------------
  |  Branch (2076:17): [True: 5, False: 13.7k]
  ------------------
 2077|       |                // Character reference was not in the valid range
 2078|      5|                emitError(XMLErrs::InvalidCharacterRef);
 2079|      5|                return false;
 2080|      5|            }
 2081|  13.7k|        }
 2082|       |
 2083|       |        // Indicate that we got at least one good digit
 2084|  13.7k|        gotOne = true;
 2085|       |
 2086|       |        // And eat the last char
 2087|  13.7k|        fReaderMgr.getNextChar();
 2088|  13.7k|    }
 2089|       |
 2090|       |    // Return the char (or chars)
 2091|       |    // And check if the character expanded is valid or not
 2092|  9.68k|    if (value >= 0x10000 && value <= 0x10FFFF)
  ------------------
  |  Branch (2092:9): [True: 653, False: 9.03k]
  |  Branch (2092:29): [True: 653, False: 0]
  ------------------
 2093|    653|    {
 2094|    653|        value -= 0x10000;
 2095|    653|        toFill = XMLCh((value >> 10) + 0xD800);
 2096|    653|        second = XMLCh((value & 0x3FF) + 0xDC00);
 2097|    653|    }
 2098|  9.03k|    else if (value <= 0xFFFD)
  ------------------
  |  Branch (2098:14): [True: 9.02k, False: 6]
  ------------------
 2099|  9.02k|    {
 2100|  9.02k|        toFill = XMLCh(value);
 2101|  9.02k|        second = 0;
 2102|  9.02k|        if (!fReaderMgr.getCurrentReader()->isXMLChar(toFill) && !fReaderMgr.getCurrentReader()->isControlChar(toFill)) {
  ------------------
  |  Branch (2102:13): [True: 40, False: 8.98k]
  |  Branch (2102:66): [True: 6, False: 34]
  ------------------
 2103|       |            // Character reference was not in the valid range
 2104|      6|            emitError(XMLErrs::InvalidCharacterRef);
 2105|      6|            return false;
 2106|      6|        }
 2107|  9.02k|    }
 2108|      6|    else {
 2109|       |        // Character reference was not in the valid range
 2110|      6|        emitError(XMLErrs::InvalidCharacterRef);
 2111|      6|        return false;
 2112|      6|    }
 2113|       |
 2114|  9.67k|    return true;
 2115|  9.68k|}
_ZN11xercesc_3_210XMLScanner11scanCommentEv:
 2124|  1.01k|{
 2125|       |
 2126|  1.01k|    enum States
 2127|  1.01k|    {
 2128|  1.01k|        InText
 2129|  1.01k|        , OneDash
 2130|  1.01k|        , TwoDashes
 2131|  1.01k|    };
 2132|       |
 2133|       |    // Get a buffer for this
 2134|  1.01k|    XMLBufBid bbComment(&fBufMgr);
 2135|       |
 2136|       |    //  Get the comment text into a temp buffer. Be sure to use temp buffer
 2137|       |    //  two here, since its to be used for stuff that is potentially longer
 2138|       |    //  than just a name.
 2139|  1.01k|    States curState = InText;
 2140|  1.01k|    bool gotLeadingSurrogate = false;
 2141|  14.4M|    while (true)
  ------------------
  |  Branch (2141:12): [Folded - Ignored]
  ------------------
 2142|  14.4M|    {
 2143|       |        // Get the next character
 2144|  14.4M|        const XMLCh nextCh = fReaderMgr.getNextChar();
 2145|       |
 2146|       |        //  Watch for an end of file
 2147|  14.4M|        if (!nextCh)
  ------------------
  |  Branch (2147:13): [True: 19, False: 14.4M]
  ------------------
 2148|     19|        {
 2149|     19|            emitError(XMLErrs::UnterminatedComment);
 2150|     19|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|     19|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 2151|     19|        }
 2152|       |
 2153|       |        // Check for correct surrogate pairs
 2154|  14.4M|        if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (2154:13): [True: 887, False: 14.4M]
  |  Branch (2154:35): [True: 355, False: 532]
  ------------------
 2155|    355|        {
 2156|    355|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (2156:17): [True: 0, False: 355]
  ------------------
 2157|      0|                emitError(XMLErrs::Expected2ndSurrogateChar);
 2158|    355|            else
 2159|    355|                gotLeadingSurrogate = true;
 2160|    355|        }
 2161|  14.4M|        else
 2162|  14.4M|        {
 2163|  14.4M|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (2163:17): [True: 355, False: 14.4M]
  ------------------
 2164|    355|            {
 2165|    355|                if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
  ------------------
  |  Branch (2165:21): [True: 0, False: 355]
  |  Branch (2165:42): [True: 0, False: 355]
  ------------------
 2166|      0|                    emitError(XMLErrs::Expected2ndSurrogateChar);
 2167|    355|            }
 2168|       |            // Its got to at least be a valid XML character
 2169|  14.4M|            else if (!fReaderMgr.getCurrentReader()->isXMLChar(nextCh)) {
  ------------------
  |  Branch (2169:22): [True: 8, False: 14.4M]
  ------------------
 2170|       |
 2171|      8|                XMLCh tmpBuf[9];
 2172|      8|                XMLString::binToText
 2173|      8|                (
 2174|      8|                    nextCh
 2175|      8|                    , tmpBuf
 2176|      8|                    , 8
 2177|      8|                    , 16
 2178|      8|                    , fMemoryManager
 2179|      8|                );
 2180|      8|                emitError(XMLErrs::InvalidCharacter, tmpBuf);
 2181|      8|            }
 2182|       |
 2183|  14.4M|            gotLeadingSurrogate = false;
 2184|  14.4M|        }
 2185|       |
 2186|  14.4M|        if (curState == InText)
  ------------------
  |  Branch (2186:13): [True: 14.4M, False: 4.82k]
  ------------------
 2187|  14.4M|        {
 2188|       |            // If its a dash, go to OneDash state. Otherwise take as text
 2189|  14.4M|            if (nextCh == chDash)
  ------------------
  |  Branch (2189:17): [True: 3.82k, False: 14.4M]
  ------------------
 2190|  3.82k|                curState = OneDash;
 2191|  14.4M|            else
 2192|  14.4M|                bbComment.append(nextCh);
 2193|  14.4M|        }
 2194|  4.82k|        else if (curState == OneDash)
  ------------------
  |  Branch (2194:18): [True: 3.82k, False: 995]
  ------------------
 2195|  3.82k|        {
 2196|       |            //  If its another dash, then we change to the two dashes states.
 2197|       |            //  Otherwise, we have to put in the deficit dash and the new
 2198|       |            //  character and go back to InText.
 2199|  3.82k|            if (nextCh == chDash)
  ------------------
  |  Branch (2199:17): [True: 970, False: 2.85k]
  ------------------
 2200|    970|            {
 2201|    970|                curState = TwoDashes;
 2202|    970|            }
 2203|  2.85k|            else
 2204|  2.85k|            {
 2205|  2.85k|                bbComment.append(chDash);
 2206|  2.85k|                bbComment.append(nextCh);
 2207|  2.85k|                curState = InText;
 2208|  2.85k|            }
 2209|  3.82k|        }
 2210|    995|        else if (curState == TwoDashes)
  ------------------
  |  Branch (2210:18): [True: 970, False: 25]
  ------------------
 2211|    970|        {
 2212|       |            // The next character must be the closing bracket
 2213|    970|            if (nextCh != chCloseAngle)
  ------------------
  |  Branch (2213:17): [True: 18, False: 952]
  ------------------
 2214|     18|            {
 2215|     18|                emitError(XMLErrs::IllegalSequenceInComment);
 2216|     18|                fReaderMgr.skipPastChar(chCloseAngle);
 2217|     18|                return;
 2218|     18|            }
 2219|    952|            break;
 2220|    970|        }
 2221|  14.4M|    }
 2222|       |
 2223|       |    // If we have an available handler, call back with the comment.
 2224|    977|    if (fDocHandler)
  ------------------
  |  Branch (2224:9): [True: 0, False: 977]
  ------------------
 2225|      0|    {
 2226|      0|        fDocHandler->docComment
 2227|      0|        (
 2228|      0|            bbComment.getRawBuffer()
 2229|      0|        );
 2230|      0|    }
 2231|       |
 2232|       |    //mark comment is seen within the current element
 2233|    977|    if (! fElemStack.isEmpty())
  ------------------
  |  Branch (2233:9): [True: 279, False: 698]
  ------------------
 2234|    279|        fElemStack.setCommentOrPISeen();
 2235|       |
 2236|    977|}
_ZN11xercesc_3_210XMLScanner6scanEqEb:
 2242|   498k|{
 2243|   498k|    if(inDecl)
  ------------------
  |  Branch (2243:8): [True: 24.6k, False: 473k]
  ------------------
 2244|  24.6k|    {
 2245|  24.6k|        bool skippedSomething;
 2246|  24.6k|        fReaderMgr.skipPastSpaces(skippedSomething, inDecl);
 2247|  24.6k|        if (fReaderMgr.skippedChar(chEqual))
  ------------------
  |  Branch (2247:13): [True: 24.6k, False: 0]
  ------------------
 2248|  24.6k|        {
 2249|  24.6k|            fReaderMgr.skipPastSpaces(skippedSomething, inDecl);
 2250|  24.6k|            return true;
 2251|  24.6k|        }
 2252|  24.6k|    }
 2253|   473k|    else
 2254|   473k|    {
 2255|   473k|        fReaderMgr.skipPastSpaces();
 2256|   473k|        if (fReaderMgr.skippedChar(chEqual))
  ------------------
  |  Branch (2256:13): [True: 473k, False: 44]
  ------------------
 2257|   473k|        {
 2258|   473k|            fReaderMgr.skipPastSpaces();
 2259|   473k|            return true;
 2260|   473k|        }
 2261|   473k|    }
 2262|     44|    return false;
 2263|   498k|}
_ZN11xercesc_3_210XMLScanner12scanUpToWSOrERNS_9XMLBufferEDs:
 2268|  24.6k|{
 2269|  24.6k|    fReaderMgr.getUpToCharOrWS(toFill, chEndChar);
 2270|  24.6k|    return toFill.getLen();
 2271|  24.6k|}
_ZN11xercesc_3_210XMLScanner13getNewUIntPtrEv:
 2274|    705|{
 2275|       |    // this method hands back a new pointer initialized to 0
 2276|    705|    unsigned int *retVal;
 2277|    705|    if(fUIntPoolCol < 64)
  ------------------
  |  Branch (2277:8): [True: 705, False: 0]
  ------------------
 2278|    705|    {
 2279|    705|        retVal = fUIntPool[fUIntPoolRow]+fUIntPoolCol;
 2280|    705|        fUIntPoolCol++;
 2281|    705|        return retVal;
 2282|    705|    }
 2283|       |    // time to grow the pool...
 2284|      0|    if(fUIntPoolRow+1 == fUIntPoolRowTotal)
  ------------------
  |  Branch (2284:8): [True: 0, False: 0]
  ------------------
 2285|      0|    {
 2286|       |        // and time to add some space for new rows:
 2287|      0|        fUIntPoolRowTotal <<= 1;
 2288|      0|        unsigned int **newArray = (unsigned int **)fMemoryManager->allocate(sizeof(unsigned int *) * fUIntPoolRowTotal );
 2289|      0|        memcpy(newArray, fUIntPool, (fUIntPoolRow+1) * sizeof(unsigned int *));
 2290|      0|        fMemoryManager->deallocate(fUIntPool);
 2291|      0|        fUIntPool = newArray;
 2292|       |        // need to 0 out new elements we won't need:
 2293|      0|        for (unsigned int i=fUIntPoolRow+2; i<fUIntPoolRowTotal; i++)
  ------------------
  |  Branch (2293:45): [True: 0, False: 0]
  ------------------
 2294|      0|            fUIntPool[i] = 0;
 2295|      0|    }
 2296|       |    // now to add a new row; we just made sure we have space
 2297|      0|    fUIntPoolRow++;
 2298|      0|    fUIntPool[fUIntPoolRow] = (unsigned int *)fMemoryManager->allocate(sizeof(unsigned int) << 6);
 2299|      0|    memset(fUIntPool[fUIntPoolRow], 0, sizeof(unsigned int) << 6);
 2300|       |    // point to next element
 2301|      0|    fUIntPoolCol = 1;
 2302|      0|    return fUIntPool[fUIntPoolRow];
 2303|    705|}
_ZN11xercesc_3_210XMLScanner13resetUIntPoolEv:
 2306|  8.51k|{
 2307|       |    // to reuse the unsigned int pool--and the hashtables that use it--
 2308|       |    // simply reinitialize everything to 0's
 2309|  17.0k|    for(unsigned int i = 0; i<= fUIntPoolRow; i++)
  ------------------
  |  Branch (2309:29): [True: 8.51k, False: 8.51k]
  ------------------
 2310|  8.51k|        memset(fUIntPool[i], 0, sizeof(unsigned int) << 6);
 2311|  8.51k|}

_ZN11xercesc_3_210XMLScanner19incrementErrorCountEv:
 1407|  1.28M|{
 1408|  1.28M|    ++fErrorCount;
 1409|  1.28M|}
_ZNK11xercesc_3_210XMLScanner28getValidationConstraintFatalEv:
  939|  1.27M|{
  940|  1.27M|    return fValidationConstraintFatal;
  941|  1.27M|}
_ZNK11xercesc_3_210XMLScanner16getMemoryManagerEv:
 1130|  39.5k|{
 1131|  39.5k|    return fMemoryManager;
 1132|  39.5k|}
_ZNK11xercesc_3_210XMLScanner15getDoNamespacesEv:
  889|  34.6k|{
  890|  34.6k|    return fDoNamespaces;
  891|  34.6k|}
_ZN11xercesc_3_210XMLScanner14getPSVIHandlerEv:
  929|  8.51k|{
  930|  8.51k|    return fPSVIHandler;
  931|  8.51k|}
_ZN11xercesc_3_210XMLScanner12getIDRefListEv:
  949|  22.5k|{
  950|  22.5k|    return fValidationContext->getIdRefList();
  951|  22.5k|}
_ZNK11xercesc_3_210XMLScanner13getStandaloneEv:
  985|  15.1k|{
  986|  15.1k|    return fStandalone;
  987|  15.1k|}
_ZNK11xercesc_3_210XMLScanner19getValidationSchemeEv:
  990|  42.1k|{
  991|  42.1k|    return fValScheme;
  992|  42.1k|}
_ZNK11xercesc_3_210XMLScanner19getEmptyNamespaceIdEv:
 1030|  21.3k|{
 1031|  21.3k|    return fEmptyNamespaceId;
 1032|  21.3k|}
_ZNK11xercesc_3_210XMLScanner11getHasNoDTDEv:
 1060|  14.2k|{
 1061|  14.2k|    return fHasNoDTD;
 1062|  14.2k|}
_ZNK11xercesc_3_210XMLScanner18getCalculateSrcOfsEv:
 1110|      1|{
 1111|      1|    return fCalculateSrcOfs;
 1112|      1|}
_ZNK11xercesc_3_210XMLScanner15getLowWaterMarkEv:
 1160|      1|{
 1161|      1|    return fLowWaterMark;
 1162|      1|}
_ZNK11xercesc_3_210XMLScanner33getDisableDefaultEntityResolutionEv:
 1175|      1|{
 1176|      1|    return fDisableDefaultEntityResolution;
 1177|      1|}
_ZN11xercesc_3_210XMLScanner19setValidationSchemeENS0_10ValSchemesE:
 1240|  8.51k|{
 1241|  8.51k|    fValScheme = newScheme;
 1242|       |
 1243|       |    // validation flag for Val_Auto is set to false by default,
 1244|       |    //   and will be turned to true if a grammar is seen
 1245|  8.51k|    if (fValScheme == Val_Always)
  ------------------
  |  Branch (1245:9): [True: 0, False: 8.51k]
  ------------------
 1246|      0|        fValidate = true;
 1247|  8.51k|    else
 1248|  8.51k|        fValidate = false;
 1249|  8.51k|}
_ZN11xercesc_3_210XMLScanner11setDoSchemaEb:
 1252|  8.51k|{
 1253|  8.51k|    fDoSchema = doSchema;
 1254|  8.51k|}
_ZN11xercesc_3_210XMLScanner15setDoNamespacesEb:
 1257|  8.51k|{
 1258|  8.51k|    fDoNamespaces = doNamespaces;
 1259|  8.51k|}
_ZN11xercesc_3_210XMLScanner31setValidationSchemaFullCheckingEb:
 1262|  8.51k|{
 1263|  8.51k|    fSchemaFullChecking = schemaFullChecking;
 1264|  8.51k|}
_ZN11xercesc_3_210XMLScanner11setHasNoDTDEb:
 1272|  3.47k|{
 1273|  3.47k|    fHasNoDTD = hasNoDTD;
 1274|  3.47k|}
_ZN11xercesc_3_210XMLScanner15setRootElemNameEPDs:
 1277|  8.30k|{
 1278|  8.30k|    fMemoryManager->deallocate(fRootElemName);//delete [] fRootElemName;
 1279|  8.30k|    fRootElemName = XMLString::replicate(rootElemName, fMemoryManager);
 1280|  8.30k|}
_ZN11xercesc_3_210XMLScanner24setHandleMultipleImportsEb:
 1399|  8.51k|{
 1400|  8.51k|    fHandleMultipleImports = newValue;
 1401|  8.51k|}
_ZN11xercesc_3_210XMLScanner22resetValidationContextEv:
 1412|  8.51k|{
 1413|  8.51k|    fValidationContext->clearIdRefList();
 1414|  8.51k|    fValidationContext->setEntityDeclPool(0);
 1415|  8.51k|    fEntityDeclPoolRetrieved = false;
 1416|  8.51k|}

_ZN11xercesc_3_218XMLScannerResolver17getDefaultScannerEPNS_12XMLValidatorEPNS_15GrammarResolverEPNS_13MemoryManagerE:
   41|  8.51k|{
   42|  8.51k|    return new (manager) IGXMLScanner(valToAdopt, grammarResolver, manager);
   43|  8.51k|}

_ZN11xercesc_3_213XSerializableD2Ev:
   37|  6.16M|    virtual ~XSerializable() {} ;
_ZN11xercesc_3_213XSerializableC2Ev:
   49|  4.61M|    XSerializable() {}
_ZN11xercesc_3_213XSerializableC2ERKS0_:
   50|  1.55M|    XSerializable(const XSerializable& ) {}             

_ZN11xercesc_3_213__AbortFilterC2Ev:
   66|      2|    __AbortFilter() {}

_ZN11xercesc_3_29SAXParserC2EPNS_12XMLValidatorEPNS_13MemoryManagerEPNS_14XMLGrammarPoolE:
   77|  8.51k|{
   78|  8.51k|    CleanupType cleanup(this, &SAXParser::cleanUp);
   79|       |
   80|  8.51k|    try
   81|  8.51k|    {
   82|  8.51k|        initialize();
   83|  8.51k|    }
   84|  8.51k|    catch(const OutOfMemoryException&)
   85|  8.51k|    {
   86|       |        // Don't cleanup when out of memory, since executing the
   87|       |        // code can cause problems.
   88|      0|        cleanup.release();
   89|       |
   90|      0|        throw;
   91|      0|    }
   92|       |
   93|  8.51k|    cleanup.release();
   94|  8.51k|}
_ZN11xercesc_3_29SAXParserD2Ev:
   98|  8.51k|{
   99|  8.51k|    cleanUp();
  100|  8.51k|}
_ZN11xercesc_3_29SAXParser10initializeEv:
  106|  8.51k|{
  107|       |    // Create grammar resolver and string pool to pass to scanner
  108|  8.51k|    fGrammarResolver = new (fMemoryManager) GrammarResolver(fGrammarPool, fMemoryManager);
  109|  8.51k|    fURIStringPool = fGrammarResolver->getStringPool();
  110|       |
  111|       |    // Create our scanner and tell it what validator to use
  112|  8.51k|    fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fGrammarResolver, fMemoryManager);
  113|  8.51k|    fScanner->setURIStringPool(fURIStringPool);
  114|       |
  115|       |    // Create the initial advanced handler list array and zero it out
  116|  8.51k|    fAdvDHList = (XMLDocumentHandler**) fMemoryManager->allocate
  117|  8.51k|    (
  118|  8.51k|        fAdvDHListSize * sizeof(XMLDocumentHandler*)
  119|  8.51k|    );//new XMLDocumentHandler*[fAdvDHListSize];
  120|  8.51k|    memset(fAdvDHList, 0, sizeof(void*) * fAdvDHListSize);
  121|  8.51k|}
_ZN11xercesc_3_29SAXParser7cleanUpEv:
  124|  8.51k|{
  125|  8.51k|    fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
  126|  8.51k|    delete fScanner;
  127|  8.51k|    delete fGrammarResolver;
  128|       |    // grammar pool must do this
  129|       |    //delete fURIStringPool;
  130|       |
  131|  8.51k|    if (fValidator)
  ------------------
  |  Branch (131:9): [True: 0, False: 8.51k]
  ------------------
  132|      0|        delete fValidator;
  133|  8.51k|}
_ZN11xercesc_3_29SAXParser15setDoNamespacesEb:
  394|  8.51k|{
  395|  8.51k|    fScanner->setDoNamespaces(newState);
  396|  8.51k|}
_ZN11xercesc_3_29SAXParser19setValidationSchemeENS0_10ValSchemesE:
  421|  8.51k|{
  422|  8.51k|    if (newScheme == Val_Never)
  ------------------
  |  Branch (422:9): [True: 0, False: 8.51k]
  ------------------
  423|      0|        fScanner->setValidationScheme(XMLScanner::Val_Never);
  424|  8.51k|    else if (newScheme == Val_Always)
  ------------------
  |  Branch (424:14): [True: 0, False: 8.51k]
  ------------------
  425|      0|        fScanner->setValidationScheme(XMLScanner::Val_Always);
  426|  8.51k|    else
  427|  8.51k|        fScanner->setValidationScheme(XMLScanner::Val_Auto);
  428|  8.51k|}
_ZN11xercesc_3_29SAXParser11setDoSchemaEb:
  431|  8.51k|{
  432|  8.51k|    fScanner->setDoSchema(newState);
  433|  8.51k|}
_ZN11xercesc_3_29SAXParser31setValidationSchemaFullCheckingEb:
  436|  8.51k|{
  437|  8.51k|    fScanner->setValidationSchemaFullChecking(schemaFullChecking);
  438|  8.51k|}
_ZN11xercesc_3_29SAXParser24setHandleMultipleImportsEb:
  557|  8.51k|{
  558|  8.51k|    fScanner->setHandleMultipleImports(newValue);
  559|  8.51k|}
_ZN11xercesc_3_29SAXParser5parseERKNS_11InputSourceE:
  565|  8.51k|{
  566|       |    // Avoid multiple entrance
  567|  8.51k|    if (fParseInProgress)
  ------------------
  |  Branch (567:9): [True: 0, False: 8.51k]
  ------------------
  568|      0|        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  569|       |
  570|  8.51k|    ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
  571|       |
  572|  8.51k|    try
  573|  8.51k|    {
  574|  8.51k|        fParseInProgress = true;
  575|  8.51k|        fScanner->scanDocument(source);
  576|  8.51k|    }
  577|  8.51k|    catch(const OutOfMemoryException&)
  578|  8.51k|    {
  579|      0|        resetInProgress.release();
  580|       |
  581|      0|        throw;
  582|      0|    }
  583|  8.51k|}
_ZN11xercesc_3_29SAXParser15resetInProgressEv:
 1341|  8.51k|{
 1342|  8.51k|    fParseInProgress = false;
 1343|  8.51k|}

_ZN11xercesc_3_213AttributeListC2Ev:
   90|  8.51k|    {
   91|  8.51k|    }
_ZN11xercesc_3_213AttributeListD2Ev:
   95|  8.51k|    {
   96|  8.51k|    }

_ZN11xercesc_3_211InputSourceD2Ev:
   35|  10.9k|{
   36|  10.9k|    fMemoryManager->deallocate(fEncoding);
   37|  10.9k|    fMemoryManager->deallocate(fPublicId);
   38|  10.9k|    fMemoryManager->deallocate(fSystemId);
   39|  10.9k|}
_ZN11xercesc_3_211InputSource11setSystemIdEPKDs:
   60|  2.38k|{
   61|  2.38k|    fMemoryManager->deallocate(fSystemId);
   62|  2.38k|    fSystemId = XMLString::replicate(systemId, fMemoryManager);
   63|  2.38k|}
_ZN11xercesc_3_211InputSourceC2EPNS_13MemoryManagerE:
   77|  2.38k|{
   78|  2.38k|}
_ZN11xercesc_3_211InputSourceC2EPKcPNS_13MemoryManagerE:
  114|  8.51k|{
  115|  8.51k|    fSystemId = XMLString::transcode(systemId, fMemoryManager);
  116|  8.51k|}

_ZNK11xercesc_3_211InputSource11getEncodingEv:
  303|  8.52k|{
  304|  8.52k|    return fEncoding;
  305|  8.52k|}
_ZNK11xercesc_3_211InputSource11getPublicIdEv:
  308|  8.52k|{
  309|  8.52k|    return fPublicId;
  310|  8.52k|}
_ZNK11xercesc_3_211InputSource11getSystemIdEv:
  313|  12.8k|{
  314|  12.8k|    return fSystemId;
  315|  12.8k|}
_ZNK11xercesc_3_211InputSource16getMemoryManagerEv:
  323|  21.5k|{
  324|  21.5k|    return fMemoryManager;
  325|  21.5k|}

_ZN11xercesc_3_27LocatorC2Ev:
   62|  8.51k|    {
   63|  8.51k|    }
_ZN11xercesc_3_27LocatorD2Ev:
   67|  8.51k|    {
   68|  8.51k|    }

_ZN11xercesc_3_26ParserC2Ev:
   70|  8.51k|    {
   71|  8.51k|    }
_ZN11xercesc_3_26ParserD2Ev:
   74|  8.51k|    {
   75|  8.51k|    }

_ZN11xercesc_3_215BaseRefVectorOfINS_8ENameMapEEC2EmbPNS_13MemoryManagerE:
   39|      1|{
   40|       |    // Allocate and initialize the array
   41|      1|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|      9|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 8, False: 1]
  ------------------
   43|      8|        fElemList[index] = 0;
   44|      1|}
_ZN11xercesc_3_215BaseRefVectorOfINS_8ENameMapEE12setElementAtEPS1_m:
   66|      8|{
   67|      8|    if (setAt >= fCurCount)
  ------------------
  |  Branch (67:9): [True: 0, False: 8]
  ------------------
   68|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   69|       |
   70|      8|    if (fAdoptedElems)
  ------------------
  |  Branch (70:9): [True: 8, False: 0]
  ------------------
   71|      8|        delete fElemList[setAt];
   72|      8|    fElemList[setAt] = toSet;
   73|      8|}
_ZN11xercesc_3_215BaseRefVectorOfINS_8ENameMapEE9elementAtEm:
  248|  17.0k|{
  249|  17.0k|    if (getAt >= fCurCount)
  ------------------
  |  Branch (249:9): [True: 0, False: 17.0k]
  ------------------
  250|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  251|  17.0k|    return fElemList[getAt];
  252|  17.0k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_8ENameMapEE10addElementEPS1_:
   57|      8|{
   58|      8|    ensureExtraCapacity(1);
   59|      8|    fElemList[fCurCount] = toAdd;
   60|      8|    fCurCount++;
   61|      8|}
_ZN11xercesc_3_215BaseRefVectorOfINS_8ENameMapEE19ensureExtraCapacityEm:
  265|      8|{
  266|      8|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|      8|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 8, False: 0]
  ------------------
  269|      8|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      0|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 0, False: 0]
  ------------------
  274|      0|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      0|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      0|    (
  279|      0|        newMax * sizeof(TElem*)
  280|      0|    );//new TElem*[newMax];
  281|      0|    XMLSize_t index = 0;
  282|      0|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 0, False: 0]
  ------------------
  283|      0|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|      0|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 0, False: 0]
  ------------------
  287|      0|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      0|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      0|    fElemList = newList;
  292|      0|    fMaxCount = newMax;
  293|      0|}
_ZN11xercesc_3_215BaseRefVectorOfIDsEC2EmbPNS_13MemoryManagerE:
   39|      1|{
   40|       |    // Allocate and initialize the array
   41|      1|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|      5|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 4, False: 1]
  ------------------
   43|      4|        fElemList[index] = 0;
   44|      1|}
_ZN11xercesc_3_215BaseRefVectorOfIDsED2Ev:
   49|      1|{
   50|      1|}
_ZN11xercesc_3_215BaseRefVectorOfIDsE10addElementEPDs:
   57|      1|{
   58|      1|    ensureExtraCapacity(1);
   59|      1|    fElemList[fCurCount] = toAdd;
   60|      1|    fCurCount++;
   61|      1|}
_ZN11xercesc_3_215BaseRefVectorOfIDsE19ensureExtraCapacityEm:
  265|      1|{
  266|      1|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|      1|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 1, False: 0]
  ------------------
  269|      1|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      0|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 0, False: 0]
  ------------------
  274|      0|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      0|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      0|    (
  279|      0|        newMax * sizeof(TElem*)
  280|      0|    );//new TElem*[newMax];
  281|      0|    XMLSize_t index = 0;
  282|      0|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 0, False: 0]
  ------------------
  283|      0|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|      0|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 0, False: 0]
  ------------------
  287|      0|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      0|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      0|    fElemList = newList;
  292|      0|    fMaxCount = newMax;
  293|      0|}
_ZN11xercesc_3_215BaseRefVectorOfINS_23DOMImplementationSourceEEC2EmbPNS_13MemoryManagerE:
   39|      1|{
   40|       |    // Allocate and initialize the array
   41|      1|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|      4|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 3, False: 1]
  ------------------
   43|      3|        fElemList[index] = 0;
   44|      1|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_23DOMImplementationSourceEE4sizeEv:
  255|      2|{
  256|      2|    return fCurCount;
  257|      2|}
_ZN11xercesc_3_215BaseRefVectorOfINS_23DOMImplementationSourceEE10addElementEPS1_:
   57|      1|{
   58|      1|    ensureExtraCapacity(1);
   59|      1|    fElemList[fCurCount] = toAdd;
   60|      1|    fCurCount++;
   61|      1|}
_ZN11xercesc_3_215BaseRefVectorOfINS_23DOMImplementationSourceEE19ensureExtraCapacityEm:
  265|      1|{
  266|      1|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|      1|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 1, False: 0]
  ------------------
  269|      1|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      0|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 0, False: 0]
  ------------------
  274|      0|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      0|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      0|    (
  279|      0|        newMax * sizeof(TElem*)
  280|      0|    );//new TElem*[newMax];
  281|      0|    XMLSize_t index = 0;
  282|      0|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 0, False: 0]
  ------------------
  283|      0|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|      0|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 0, False: 0]
  ------------------
  287|      0|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      0|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      0|    fElemList = newList;
  292|      0|    fMaxCount = newMax;
  293|      0|}
_ZN11xercesc_3_215BaseRefVectorOfINS_23DOMImplementationSourceEE9elementAtEm:
  248|      1|{
  249|      1|    if (getAt >= fCurCount)
  ------------------
  |  Branch (249:9): [True: 0, False: 1]
  ------------------
  250|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  251|      1|    return fElemList[getAt];
  252|      1|}
_ZN11xercesc_3_215BaseRefVectorOfINS_7XMLAttrEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|   281k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 272k, False: 8.51k]
  ------------------
   43|   272k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_7XMLAttrEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_7XMLAttrEE10addElementEPS1_:
   57|  3.11k|{
   58|  3.11k|    ensureExtraCapacity(1);
   59|  3.11k|    fElemList[fCurCount] = toAdd;
   60|  3.11k|    fCurCount++;
   61|  3.11k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_7XMLAttrEE19ensureExtraCapacityEm:
  265|  3.11k|{
  266|  3.11k|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|  3.11k|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 3.11k, False: 1]
  ------------------
  269|  3.11k|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      1|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 1, False: 0]
  ------------------
  274|      1|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      1|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      1|    (
  279|      1|        newMax * sizeof(TElem*)
  280|      1|    );//new TElem*[newMax];
  281|      1|    XMLSize_t index = 0;
  282|     33|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 32, False: 1]
  ------------------
  283|     32|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|     17|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 16, False: 1]
  ------------------
  287|     16|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      1|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      1|    fElemList = newList;
  292|      1|    fMaxCount = newMax;
  293|      1|}
_ZN11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEE17removeAllElementsEv:
  129|  8.51k|{
  130|  8.57k|    for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (130:31): [True: 61, False: 8.51k]
  ------------------
  131|     61|    {
  132|     61|        if (fAdoptedElems)
  ------------------
  |  Branch (132:13): [True: 61, False: 0]
  ------------------
  133|     61|          delete fElemList[index];
  134|       |
  135|       |        // Keep unused elements zero for sanity's sake
  136|     61|        fElemList[index] = 0;
  137|     61|    }
  138|  8.51k|    fCurCount = 0;
  139|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEE17removeAllElementsEv:
  129|  8.51k|{
  130|  8.57k|    for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (130:31): [True: 61, False: 8.51k]
  ------------------
  131|     61|    {
  132|     61|        if (fAdoptedElems)
  ------------------
  |  Branch (132:13): [True: 0, False: 61]
  ------------------
  133|      0|          delete fElemList[index];
  134|       |
  135|       |        // Keep unused elements zero for sanity's sake
  136|     61|        fElemList[index] = 0;
  137|     61|    }
  138|  8.51k|    fCurCount = 0;
  139|  8.51k|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEE4sizeEv:
  255|  41.6k|{
  256|  41.6k|    return fCurCount;
  257|  41.6k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEE15orphanElementAtEm:
  100|  16.8k|{
  101|  16.8k|    if (orphanAt >= fCurCount)
  ------------------
  |  Branch (101:9): [True: 0, False: 16.8k]
  ------------------
  102|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  103|       |
  104|       |    // Get the element we are going to orphan
  105|  16.8k|    TElem* retVal = fElemList[orphanAt];
  106|       |
  107|       |    // Optimize if its the last element
  108|  16.8k|    if (orphanAt == fCurCount-1)
  ------------------
  |  Branch (108:9): [True: 16.8k, False: 0]
  ------------------
  109|  16.8k|    {
  110|  16.8k|        fElemList[orphanAt] = 0;
  111|  16.8k|        fCurCount--;
  112|  16.8k|        return retVal;
  113|  16.8k|    }
  114|       |
  115|       |    // Copy down every element above orphan point
  116|      0|    for (XMLSize_t index = orphanAt; index < fCurCount-1; index++)
  ------------------
  |  Branch (116:38): [True: 0, False: 0]
  ------------------
  117|      0|        fElemList[index] = fElemList[index+1];
  118|       |
  119|       |    // Keep unused elements zero for sanity's sake
  120|      0|    fElemList[fCurCount-1] = 0;
  121|       |
  122|       |    // And bump down count
  123|      0|    fCurCount--;
  124|       |
  125|      0|    return retVal;
  126|  16.8k|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEE4sizeEv:
  255|  50.0k|{
  256|  50.0k|    return fCurCount;
  257|  50.0k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEE15orphanElementAtEm:
  100|  16.8k|{
  101|  16.8k|    if (orphanAt >= fCurCount)
  ------------------
  |  Branch (101:9): [True: 0, False: 16.8k]
  ------------------
  102|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  103|       |
  104|       |    // Get the element we are going to orphan
  105|  16.8k|    TElem* retVal = fElemList[orphanAt];
  106|       |
  107|       |    // Optimize if its the last element
  108|  16.8k|    if (orphanAt == fCurCount-1)
  ------------------
  |  Branch (108:9): [True: 16.8k, False: 0]
  ------------------
  109|  16.8k|    {
  110|  16.8k|        fElemList[orphanAt] = 0;
  111|  16.8k|        fCurCount--;
  112|  16.8k|        return retVal;
  113|  16.8k|    }
  114|       |
  115|       |    // Copy down every element above orphan point
  116|      0|    for (XMLSize_t index = orphanAt; index < fCurCount-1; index++)
  ------------------
  |  Branch (116:38): [True: 0, False: 0]
  ------------------
  117|      0|        fElemList[index] = fElemList[index+1];
  118|       |
  119|       |    // Keep unused elements zero for sanity's sake
  120|      0|    fElemList[fCurCount-1] = 0;
  121|       |
  122|       |    // And bump down count
  123|      0|    fCurCount--;
  124|       |
  125|      0|    return retVal;
  126|  16.8k|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEE9elementAtEm:
  240|  13.7k|{
  241|  13.7k|    if (getAt >= fCurCount)
  ------------------
  |  Branch (241:9): [True: 0, False: 13.7k]
  ------------------
  242|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  243|  13.7k|    return fElemList[getAt];
  244|  13.7k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|   144k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 136k, False: 8.51k]
  ------------------
   43|   136k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|   144k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 136k, False: 8.51k]
  ------------------
   43|   136k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEE10addElementEPS1_:
   57|  16.8k|{
   58|  16.8k|    ensureExtraCapacity(1);
   59|  16.8k|    fElemList[fCurCount] = toAdd;
   60|  16.8k|    fCurCount++;
   61|  16.8k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_9XMLReaderEE19ensureExtraCapacityEm:
  265|  16.8k|{
  266|  16.8k|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|  16.8k|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 16.8k, False: 0]
  ------------------
  269|  16.8k|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      0|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 0, False: 0]
  ------------------
  274|      0|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      0|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      0|    (
  279|      0|        newMax * sizeof(TElem*)
  280|      0|    );//new TElem*[newMax];
  281|      0|    XMLSize_t index = 0;
  282|      0|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 0, False: 0]
  ------------------
  283|      0|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|      0|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 0, False: 0]
  ------------------
  287|      0|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      0|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      0|    fElemList = newList;
  292|      0|    fMaxCount = newMax;
  293|      0|}
_ZN11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEE10addElementEPS1_:
   57|  16.8k|{
   58|  16.8k|    ensureExtraCapacity(1);
   59|  16.8k|    fElemList[fCurCount] = toAdd;
   60|  16.8k|    fCurCount++;
   61|  16.8k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_13XMLEntityDeclEE19ensureExtraCapacityEm:
  265|  16.8k|{
  266|  16.8k|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|  16.8k|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 16.8k, False: 0]
  ------------------
  269|  16.8k|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      0|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 0, False: 0]
  ------------------
  274|      0|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      0|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      0|    (
  279|      0|        newMax * sizeof(TElem*)
  280|      0|    );//new TElem*[newMax];
  281|      0|    XMLSize_t index = 0;
  282|      0|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 0, False: 0]
  ------------------
  283|      0|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|      0|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 0, False: 0]
  ------------------
  287|      0|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      0|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      0|    fElemList = newList;
  292|      0|    fMaxCount = newMax;
  293|      0|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_5TokenEE4sizeEv:
  255|     23|{
  256|     23|    return fCurCount;
  257|     23|}
_ZN11xercesc_3_215BaseRefVectorOfINS_5TokenEE9elementAtEm:
  248|     32|{
  249|     32|    if (getAt >= fCurCount)
  ------------------
  |  Branch (249:9): [True: 0, False: 32]
  ------------------
  250|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  251|     32|    return fElemList[getAt];
  252|     32|}
_ZN11xercesc_3_215BaseRefVectorOfINS_5TokenEEC2EmbPNS_13MemoryManagerE:
   39|     11|{
   40|       |    // Allocate and initialize the array
   41|     11|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|    139|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 128, False: 11]
  ------------------
   43|    128|        fElemList[index] = 0;
   44|     11|}
_ZN11xercesc_3_215BaseRefVectorOfINS_5TokenEE10addElementEPS1_:
   57|    331|{
   58|    331|    ensureExtraCapacity(1);
   59|    331|    fElemList[fCurCount] = toAdd;
   60|    331|    fCurCount++;
   61|    331|}
_ZN11xercesc_3_215BaseRefVectorOfINS_5TokenEE19ensureExtraCapacityEm:
  265|    331|{
  266|    331|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|    331|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 323, False: 8]
  ------------------
  269|    323|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      8|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 8, False: 0]
  ------------------
  274|      8|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      8|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      8|    (
  279|      8|        newMax * sizeof(TElem*)
  280|      8|    );//new TElem*[newMax];
  281|      8|    XMLSize_t index = 0;
  282|    792|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 784, False: 8]
  ------------------
  283|    784|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|    398|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 390, False: 8]
  ------------------
  287|    390|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      8|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      8|    fElemList = newList;
  292|      8|    fMaxCount = newMax;
  293|      8|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_7XMLAttrEE4sizeEv:
  255|   558k|{
  256|   558k|    return fCurCount;
  257|   558k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_2OpEEC2EmbPNS_13MemoryManagerE:
   39|      5|{
   40|       |    // Allocate and initialize the array
   41|      5|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|     71|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 66, False: 5]
  ------------------
   43|     66|        fElemList[index] = 0;
   44|      5|}
_ZNK11xercesc_3_215BaseRefVectorOfINS_2OpEE4sizeEv:
  255|     16|{
  256|     16|    return fCurCount;
  257|     16|}
_ZN11xercesc_3_215BaseRefVectorOfINS_2OpEE9elementAtEm:
  248|     27|{
  249|     27|    if (getAt >= fCurCount)
  ------------------
  |  Branch (249:9): [True: 0, False: 27]
  ------------------
  250|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  251|     27|    return fElemList[getAt];
  252|     27|}
_ZN11xercesc_3_215BaseRefVectorOfINS_2OpEE10addElementEPS1_:
   57|     74|{
   58|     74|    ensureExtraCapacity(1);
   59|     74|    fElemList[fCurCount] = toAdd;
   60|     74|    fCurCount++;
   61|     74|}
_ZN11xercesc_3_215BaseRefVectorOfINS_2OpEE19ensureExtraCapacityEm:
  265|     74|{
  266|     74|    XMLSize_t newMax = fCurCount + length;
  267|       |
  268|     74|    if (newMax <= fMaxCount)
  ------------------
  |  Branch (268:9): [True: 70, False: 4]
  ------------------
  269|     70|        return;
  270|       |
  271|       |	// Choose how much bigger based on the current size.
  272|       |	// This will grow half as much again.
  273|      4|    if (newMax < fMaxCount + fMaxCount/2)
  ------------------
  |  Branch (273:9): [True: 4, False: 0]
  ------------------
  274|      4|        newMax = fMaxCount + fMaxCount/2;
  275|       |
  276|       |    // Allocate the new array and copy over the existing stuff
  277|      4|    TElem** newList = (TElem**) fMemoryManager->allocate
  278|      4|    (
  279|      4|        newMax * sizeof(TElem*)
  280|      4|    );//new TElem*[newMax];
  281|      4|    XMLSize_t index = 0;
  282|     84|    for (; index < fCurCount; index++)
  ------------------
  |  Branch (282:12): [True: 80, False: 4]
  ------------------
  283|     80|        newList[index] = fElemList[index];
  284|       |
  285|       |    // Zero out the rest of them
  286|     44|    for (; index < newMax; index++)
  ------------------
  |  Branch (286:12): [True: 40, False: 4]
  ------------------
  287|     40|        newList[index] = 0;
  288|       |
  289|       |    // Clean up the old array and update our members
  290|      4|    fMemoryManager->deallocate(fElemList);//delete [] fElemList;
  291|      4|    fElemList = newList;
  292|      4|    fMaxCount = newMax;
  293|      4|}
_ZN11xercesc_3_215BaseRefVectorOfINS_20PSVIAttributeStorageEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|  93.6k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 85.1k, False: 8.51k]
  ------------------
   43|  85.1k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_20PSVIAttributeStorageEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_7XMLAttrEE9elementAtEm:
  248|   514k|{
  249|   514k|    if (getAt >= fCurCount)
  ------------------
  |  Branch (249:9): [True: 0, False: 514k]
  ------------------
  250|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  251|   514k|    return fElemList[getAt];
  252|   514k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_12KVStringPairEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|   281k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 272k, False: 8.51k]
  ------------------
   43|   272k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_12KVStringPairEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEE17removeAllElementsEv:
  129|  8.51k|{
  130|  8.51k|    for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (130:31): [True: 0, False: 8.51k]
  ------------------
  131|      0|    {
  132|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (132:13): [True: 0, False: 0]
  ------------------
  133|      0|          delete fElemList[index];
  134|       |
  135|       |        // Keep unused elements zero for sanity's sake
  136|      0|        fElemList[index] = 0;
  137|      0|    }
  138|  8.51k|    fCurCount = 0;
  139|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_10ValueStoreEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|  76.6k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 68.1k, False: 8.51k]
  ------------------
   43|  68.1k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_10ValueStoreEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_10ValueStoreEE17removeAllElementsEv:
  129|  8.51k|{
  130|  8.51k|    for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (130:31): [True: 0, False: 8.51k]
  ------------------
  131|      0|    {
  132|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (132:13): [True: 0, False: 0]
  ------------------
  133|      0|          delete fElemList[index];
  134|       |
  135|       |        // Keep unused elements zero for sanity's sake
  136|      0|        fElemList[index] = 0;
  137|      0|    }
  138|  8.51k|    fCurCount = 0;
  139|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|  76.6k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 68.1k, False: 8.51k]
  ------------------
   43|  68.1k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_12XPathMatcherEEC2EmbPNS_13MemoryManagerE:
   39|  8.51k|{
   40|       |    // Allocate and initialize the array
   41|  8.51k|    fElemList = (TElem**) fMemoryManager->allocate(maxElems * sizeof(TElem*));//new TElem*[maxElems];
   42|  76.6k|    for (XMLSize_t index = 0; index < maxElems; index++)
  ------------------
  |  Branch (42:31): [True: 68.1k, False: 8.51k]
  ------------------
   43|  68.1k|        fElemList[index] = 0;
   44|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_12XPathMatcherEED2Ev:
   49|  8.51k|{
   50|  8.51k|}
_ZN11xercesc_3_215BaseRefVectorOfINS_12XPathMatcherEE17removeAllElementsEv:
  129|  8.51k|{
  130|  8.51k|    for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (130:31): [True: 0, False: 8.51k]
  ------------------
  131|      0|    {
  132|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (132:13): [True: 0, False: 0]
  ------------------
  133|      0|          delete fElemList[index];
  134|       |
  135|       |        // Keep unused elements zero for sanity's sake
  136|      0|        fElemList[index] = 0;
  137|      0|    }
  138|  8.51k|    fCurCount = 0;
  139|  8.51k|}

_ZN11xercesc_3_218BinFileInputStreamC2EPKDsPNS_13MemoryManagerE:
   42|  2.23k|{
   43|  2.23k|}
_ZN11xercesc_3_218BinFileInputStreamD2Ev:
   62|  2.10k|{
   63|  2.10k|    if (getIsOpen())
  ------------------
  |  Branch (63:9): [True: 10, False: 2.09k]
  ------------------
   64|     10|    {
   65|     10|        try
   66|     10|        {
   67|     10|            XMLPlatformUtils::closeFile(fSource, fMemoryManager);
   68|     10|        }
   69|     10|        catch (...)
   70|     10|        {
   71|       |            // There is nothing we can do about it here.
   72|      0|        }
   73|     10|    }
   74|  2.10k|}
_ZN11xercesc_3_218BinFileInputStream9readBytesEPhm:
  106|     10|{
  107|       |    //
  108|       |    //  Read up to the maximum bytes requested. We return the number
  109|       |    //  actually read.
  110|       |    //
  111|     10|    return XMLPlatformUtils::readFileBuffer(fSource, maxToRead, toFill, fMemoryManager);
  112|     10|}

_ZNK11xercesc_3_218BinFileInputStream9getIsOpenEv:
  101|  4.21k|{
  102|  4.21k|    return (fSource != (FileHandle) XERCES_Invalid_File_Handle);
  ------------------
  |  |   31|  4.21k|#define XERCES_Invalid_File_Handle 0
  ------------------
  103|  4.21k|}

_ZN11xercesc_3_214BinInputStreamD2Ev:
   34|  27.7k|{
   35|  27.7k|}
_ZN11xercesc_3_214BinInputStreamC2Ev:
   42|  27.7k|{
   43|  27.7k|}
_ZNK11xercesc_3_214BinInputStream11getEncodingEv:
   49|  8.52k|{
   50|  8.52k|    return 0;
   51|  8.52k|}

_ZN11xercesc_3_217BinMemInputStreamC2EPKhmNS0_7BufOptsEPNS_13MemoryManagerE:
   44|  25.4k|{
   45|       |    // According to the buffer option, do the right thing
   46|  25.4k|    if (fBufOpt == BufOpt_Copy)
  ------------------
  |  Branch (46:9): [True: 8.51k, False: 16.8k]
  ------------------
   47|  8.51k|    {
   48|  8.51k|        XMLByte* tmpBuf = (XMLByte*) fMemoryManager->allocate
   49|  8.51k|        (
   50|  8.51k|            fCapacity * sizeof(XMLByte)
   51|  8.51k|        );//new XMLByte[fCapacity];
   52|  8.51k|        memcpy(tmpBuf, initData, capacity);
   53|  8.51k|        fBuffer = tmpBuf;
   54|  8.51k|    }
   55|  16.8k|     else
   56|  16.8k|    {
   57|  16.8k|        fBuffer = initData;
   58|  16.8k|    }
   59|  25.4k|}
_ZN11xercesc_3_217BinMemInputStreamD2Ev:
   62|  25.4k|{
   63|       |    //
   64|       |    //  If we adopted or copied the buffer, then clean it up. We have to
   65|       |    //  cast off the const'ness in that case in order to delete it.
   66|       |    //
   67|  25.4k|    if ((fBufOpt == BufOpt_Adopt) || (fBufOpt == BufOpt_Copy))
  ------------------
  |  Branch (67:9): [True: 0, False: 25.4k]
  |  Branch (67:38): [True: 8.51k, False: 16.8k]
  ------------------
   68|  8.51k|        fMemoryManager->deallocate(const_cast<XMLByte*>(fBuffer));//delete [] (XMLByte*)fBuffer;
   69|  25.4k|}
_ZN11xercesc_3_217BinMemInputStream9readBytesEPhm:
   77|  64.6k|{
   78|       |    //
   79|       |    //  Figure out how much we can really read. Its the smaller of the
   80|       |    //  amount available and the amount asked for.
   81|       |    //
   82|  64.6k|    const XMLSize_t available = (fCapacity - fCurIndex);
   83|  64.6k|    if (!available)
  ------------------
  |  Branch (83:9): [True: 36.0k, False: 28.5k]
  ------------------
   84|  36.0k|        return 0;
   85|       |
   86|  28.5k|    const XMLSize_t actualToRead = available < maxToRead ? available : maxToRead;
  ------------------
  |  Branch (86:36): [True: 22.6k, False: 5.94k]
  ------------------
   87|       |
   88|  28.5k|    memcpy(toFill, &fBuffer[fCurIndex], actualToRead);
   89|  28.5k|    fCurIndex += actualToRead;
   90|  28.5k|    return actualToRead;
   91|  64.6k|}

_ZN11xercesc_3_26BitOps9swapBytesEt:
   36|  3.67k|    {
   37|       |        //The mask is required to overcome a compiler error on solaris
   38|  3.67k|        return XMLCh(((toSwap >> 8) | (toSwap << 8)) & 0xFFFF);
   39|  3.67k|    }

_ZN11xercesc_3_219DefaultPanicHandlerC2Ev:
   46|      1|    DefaultPanicHandler(){};

_ZN11xercesc_3_214XMLInitializer27initializeEncodingValidatorEv:
   34|      1|{
   35|      1|    EncodingValidator::fInstance = new EncodingValidator();
   36|      1|}
_ZN11xercesc_3_217EncodingValidatorC2Ev:
   49|      1|{
   50|      1|    initializeRegistry();
   51|      1|}
_ZN11xercesc_3_217EncodingValidator18initializeRegistryEv:
   74|      1|void EncodingValidator::initializeRegistry() {
   75|       |
   76|      1|    fEncodingRegistry = new ValueHashTableOf<bool>(109);
   77|       |
   78|    792|    for (unsigned int i=0; i < gEncodingArraySize; i++) {
  ------------------
  |  Branch (78:28): [True: 791, False: 1]
  ------------------
   79|    791|        fEncodingRegistry->put(const_cast<void *>(reinterpret_cast<const void *>(gEncodingArray[i])), true);
   80|    791|    }
   81|      1|}

_ZN11xercesc_3_212PosixFileMgrC2Ev:
   47|      1|{
   48|      1|}
_ZN11xercesc_3_212PosixFileMgr8fileOpenEPKDsbPNS_13MemoryManagerE:
   58|  2.23k|{
   59|  2.23k|    const char* tmpFileName = XMLString::transcode(path, manager);
   60|  2.23k|    ArrayJanitor<char> janText((char*)tmpFileName, manager);
   61|  2.23k|    return fileOpen(tmpFileName, toWrite, manager);
   62|  2.23k|}
_ZN11xercesc_3_212PosixFileMgr8fileOpenEPKcbPNS_13MemoryManagerE:
   67|  2.10k|{
   68|  2.10k|    const char* perms = (toWrite) ? "wb" : "rb";
  ------------------
  |  Branch (68:25): [True: 0, False: 2.10k]
  ------------------
   69|  2.10k|    FileHandle result = (FileHandle)fopen(path , perms);
   70|  2.10k|    return result;
   71|  2.10k|}
_ZN11xercesc_3_212PosixFileMgr9fileCloseEPvPNS_13MemoryManagerE:
   83|     10|{
   84|     10|    if (!f)
  ------------------
  |  Branch (84:9): [True: 0, False: 10]
  ------------------
   85|      0|        ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::CPtr_PointerIsZero, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   86|       |
   87|     10|    if (fclose((FILE*)f))
  ------------------
  |  Branch (87:9): [True: 0, False: 10]
  ------------------
   88|      0|        ThrowXMLwithMemMgr(XMLPlatformUtilsException,
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   89|     10|                 XMLExcepts::File_CouldNotCloseFile, manager);
   90|     10|}
_ZN11xercesc_3_212PosixFileMgr8fileReadEPvmPhPNS_13MemoryManagerE:
  150|     10|{
  151|     10|    if (!f || !buffer)
  ------------------
  |  Branch (151:9): [True: 0, False: 10]
  |  Branch (151:15): [True: 0, False: 10]
  ------------------
  152|      0|        ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::CPtr_PointerIsZero, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  153|       |		
  154|     10|    XMLSize_t bytesRead = 0;
  155|     10|    if (byteCount > 0)
  ------------------
  |  Branch (155:9): [True: 10, False: 0]
  ------------------
  156|     10|    {
  157|     10|        bytesRead = fread((void*)buffer, 1, byteCount, (FILE*)f);
  158|       |
  159|     10|        if (ferror((FILE*)f))
  ------------------
  |  Branch (159:13): [True: 10, False: 0]
  ------------------
  160|     10|            ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::File_CouldNotReadFromFile, manager);
  ------------------
  |  |  264|     10|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  161|     10|    }
  162|       |	
  163|      0|    return bytesRead;
  164|     10|}
_ZN11xercesc_3_212PosixFileMgr10isRelativeEPKDsPNS_13MemoryManagerE:
  243|  2.23k|{
  244|       |    // Check for pathological case of empty path
  245|  2.23k|    if (!toCheck || !toCheck[0])
  ------------------
  |  Branch (245:9): [True: 0, False: 2.23k]
  |  Branch (245:21): [True: 1, False: 2.23k]
  ------------------
  246|      1|        return false;
  247|       |
  248|       |    //
  249|       |    //  If it starts with a slash, then it cannot be relative.
  250|       |    //
  251|  2.23k|    return toCheck[0] != chForwardSlash;
  252|  2.23k|}

_ZN11xercesc_3_211FlagJanitorIbEC2EPbb:
   37|  8.28k|{
   38|       |    // Store the pointer, save the org value, and store the new value    
   39|  8.28k|    if (fValPtr)
  ------------------
  |  Branch (39:9): [True: 8.28k, False: 0]
  ------------------
   40|  8.28k|    {
   41|  8.28k|        fOldVal = *fValPtr;
   42|  8.28k|        *fValPtr = newVal;
   43|  8.28k|    }
   44|  8.28k|}
_ZN11xercesc_3_211FlagJanitorIbED2Ev:
   47|  8.28k|{
   48|       |    // Restore the old value
   49|  8.28k|    if (fValPtr)
  ------------------
  |  Branch (49:9): [True: 8.28k, False: 0]
  ------------------
   50|  8.28k|        *fValPtr = fOldVal;
   51|  8.28k|}

_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEE9removeAllEv:
  238|   472k|{
  239|   472k|    if(isEmpty())
  ------------------
  |  Branch (239:8): [True: 15.2k, False: 456k]
  ------------------
  240|  15.2k|        return;
  241|       |
  242|  3.65M|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (242:33): [True: 3.19M, False: 456k]
  ------------------
  243|  3.19M|    {
  244|  3.19M|        if(fBucketList[buckInd]!=0)
  ------------------
  |  Branch (244:12): [True: 462k, False: 2.73M]
  ------------------
  245|   462k|        {
  246|       |            // Advance to the end of the chain, and connect it to the list of
  247|       |            // available blocks
  248|   462k|            Hash2KeysSetBucketElem* curElem = fBucketList[buckInd];
  249|   463k|            while (curElem->fNext)
  ------------------
  |  Branch (249:20): [True: 1.05k, False: 462k]
  ------------------
  250|  1.05k|                curElem = curElem->fNext;
  251|   462k|            curElem->fNext=fAvailable;
  252|   462k|            fAvailable=fBucketList[buckInd];
  253|   462k|            fBucketList[buckInd] = 0;
  254|   462k|        }
  255|  3.19M|    }
  256|   456k|    fCount=0;
  257|   456k|}
_ZNK11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEE7isEmptyEv:
  130|   480k|{
  131|   480k|    return (fCount==0);
  132|   480k|}
_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEE15putIfNotPresentEPKvi:
  319|   464k|{
  320|       |    // First see if the key exists already
  321|   464k|    XMLSize_t hashVal;
  322|   464k|    Hash2KeysSetBucketElem* newBucket = findBucketElem(key1, key2, hashVal);
  323|       |
  324|       |    //
  325|       |    //  If so,then update its value. If not, then we need to add it to
  326|       |    //  the right bucket
  327|       |    //
  328|   464k|    if (newBucket)
  ------------------
  |  Branch (328:9): [True: 28, False: 464k]
  ------------------
  329|     28|        return false;
  330|       |
  331|       |    // Apply 4 load factor to find threshold.
  332|   464k|    XMLSize_t threshold = fHashModulus * 4;
  333|       |
  334|       |    // If we've grown too big, expand the table and rehash.
  335|   464k|    if (fCount >= threshold)
  ------------------
  |  Branch (335:9): [True: 13, False: 464k]
  ------------------
  336|     13|        rehash();
  337|       |
  338|   464k|    if(fAvailable==0)
  ------------------
  |  Branch (338:8): [True: 2.41k, False: 461k]
  ------------------
  339|  2.41k|        newBucket = (Hash2KeysSetBucketElem*)fMemoryManager->allocate(sizeof(Hash2KeysSetBucketElem));
  340|   461k|    else
  341|   461k|    {
  342|   461k|        newBucket = fAvailable;
  343|   461k|        fAvailable = fAvailable->fNext;
  344|   461k|    }
  345|   464k|    newBucket->fKey1 = key1;
  346|   464k|    newBucket->fKey2 = key2;
  347|   464k|    newBucket->fNext = fBucketList[hashVal];
  348|   464k|    fBucketList[hashVal] = newBucket;
  349|   464k|    fCount++;
  350|   464k|    return true;
  351|   464k|}
_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEE14findBucketElemEPKviRm:
  360|   464k|{
  361|       |    // Hash the key
  362|   464k|    hashVal = fHasher.getHashVal(key1, fHashModulus);
  363|   464k|    assert(hashVal < fHashModulus);
  364|       |
  365|       |    // Search that bucket for the key
  366|      0|    Hash2KeysSetBucketElem* curElem = fBucketList[hashVal];
  367|   466k|    while (curElem)
  ------------------
  |  Branch (367:12): [True: 2.72k, False: 464k]
  ------------------
  368|  2.72k|    {
  369|  2.72k|        if((key2==curElem->fKey2) && (fHasher.equals(key1, curElem->fKey1)))
  ------------------
  |  Branch (369:12): [True: 2.72k, False: 0]
  |  Branch (369:38): [True: 28, False: 2.69k]
  ------------------
  370|     28|            return curElem;
  371|       |
  372|  2.69k|        curElem = curElem->fNext;
  373|  2.69k|    }
  374|   464k|    return 0;
  375|   464k|}
_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEE6rehashEv:
  401|     13|{
  402|     13|    const XMLSize_t newMod = (fHashModulus * 8)+1;
  403|       |
  404|     13|    Hash2KeysSetBucketElem** newBucketList =
  405|     13|        (Hash2KeysSetBucketElem**) fMemoryManager->allocate
  406|     13|    (
  407|     13|        newMod * sizeof(Hash2KeysSetBucketElem*)
  408|     13|    );//new Hash2KeysSetBucketElem*[fHashModulus];
  409|       |
  410|       |    // Make sure the new bucket list is destroyed if an
  411|       |    // exception is thrown.
  412|     13|    ArrayJanitor<Hash2KeysSetBucketElem*>  guard(newBucketList, fMemoryManager);
  413|       |
  414|     13|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  415|       |
  416|       |    // Rehash all existing entries.
  417|    104|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (417:31): [True: 91, False: 13]
  ------------------
  418|     91|    {
  419|       |        // Get the bucket list head for this entry
  420|     91|        Hash2KeysSetBucketElem* curElem = fBucketList[index];
  421|    455|        while (curElem)
  ------------------
  |  Branch (421:16): [True: 364, False: 91]
  ------------------
  422|    364|        {
  423|       |            // Save the next element before we detach this one
  424|    364|            Hash2KeysSetBucketElem* nextElem = curElem->fNext;
  425|       |
  426|    364|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey1, newMod);
  427|    364|            assert(hashVal < newMod);
  428|       |
  429|      0|            Hash2KeysSetBucketElem* newHeadElem = newBucketList[hashVal];
  430|       |
  431|       |            // Insert at the start of this bucket's list.
  432|    364|            curElem->fNext = newHeadElem;
  433|    364|            newBucketList[hashVal] = curElem;
  434|       |
  435|    364|            curElem = nextElem;
  436|    364|        }
  437|     91|    }
  438|       |
  439|     13|    Hash2KeysSetBucketElem** const oldBucketList = fBucketList;
  440|       |
  441|       |    // Everything is OK at this point, so update the
  442|       |    // member variables.
  443|     13|    fBucketList = guard.release();
  444|     13|    fHashModulus = newMod;
  445|       |
  446|       |    // Delete the old bucket list.
  447|     13|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  448|       |
  449|     13|}
_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|  8.51k|{
   52|  8.51k|    initialize(modulus);
   53|  8.51k|}
_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEE10initializeEm:
   73|  8.51k|{
   74|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (74:9): [True: 0, False: 8.51k]
  ------------------
   75|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   76|       |
   77|       |    // Allocate the bucket list and zero them
   78|  8.51k|    fBucketList = (Hash2KeysSetBucketElem**) fMemoryManager->allocate
   79|  8.51k|    (
   80|  8.51k|        fHashModulus * sizeof(Hash2KeysSetBucketElem*)
   81|  8.51k|    ); //new Hash2KeysSetBucketElem*[fHashModulus];
   82|  8.51k|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
   83|  8.51k|}
_ZN11xercesc_3_214Hash2KeysSetOfINS_12StringHasherEED2Ev:
   87|  8.51k|{
   88|  8.51k|    Hash2KeysSetBucketElem* nextElem;
   89|  8.51k|    if(!isEmpty())
  ------------------
  |  Branch (89:8): [True: 155, False: 8.36k]
  ------------------
   90|    155|    {
   91|       |        // Clean up the buckets first
   92|  1.39k|        for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (92:37): [True: 1.23k, False: 155]
  ------------------
   93|  1.23k|        {
   94|       |            // Get the bucket list head for this entry
   95|  1.23k|            Hash2KeysSetBucketElem* curElem = fBucketList[buckInd];
   96|  1.63k|            while (curElem)
  ------------------
  |  Branch (96:20): [True: 404, False: 1.23k]
  ------------------
   97|    404|            {
   98|       |                // Save the next element before we hose this one
   99|    404|                nextElem = curElem->fNext;
  100|    404|                fMemoryManager->deallocate(curElem);
  101|    404|                curElem = nextElem;
  102|    404|            }
  103|       |
  104|       |            // Clean out this entry
  105|  1.23k|            fBucketList[buckInd] = 0;
  106|  1.23k|        }
  107|    155|    }
  108|       |    // Then delete the list of available blocks
  109|  8.51k|    Hash2KeysSetBucketElem* curElem = fAvailable;
  110|  10.5k|    while (curElem)
  ------------------
  |  Branch (110:12): [True: 2.01k, False: 8.51k]
  ------------------
  111|  2.01k|    {
  112|       |        // Save the next element before we hose this one
  113|  2.01k|        nextElem = curElem->fNext;
  114|  2.01k|        fMemoryManager->deallocate(curElem);
  115|  2.01k|        curElem = nextElem;
  116|  2.01k|    }
  117|  8.51k|    fAvailable = 0;
  118|       |
  119|       |    // Then delete the bucket list & hasher
  120|  8.51k|    fMemoryManager->deallocate(fBucketList); //delete [] fBucketList;
  121|  8.51k|    fBucketList = 0;
  122|  8.51k|}

_ZNK11xercesc_3_212StringHasher10getHashValEPKvm:
   45|  3.48M|  {
   46|  3.48M|    return XMLString::hash ((const XMLCh*)key, mod);
   47|  3.48M|  }
_ZNK11xercesc_3_212StringHasher6equalsEPKvS2_:
   58|  2.61M|  {
   59|  2.61M|    return XMLString::equals ((const XMLCh*)key1, (const XMLCh*)key2);
   60|  2.61M|  }
_ZNK11xercesc_3_29PtrHasher10getHashValEPKvm:
   75|   253k|  {
   76|   253k|    return ((XMLSize_t)key) % mod;
   77|   253k|  }
_ZNK11xercesc_3_29PtrHasher6equalsEPKvS2_:
   88|   140k|  {
   89|   140k|    return key1 == key2;
   90|   140k|  }

_ZN11xercesc_3_212ArrayJanitorIcEC2EPcPNS_13MemoryManagerE:
  115|  50.7k|{
  116|  50.7k|}
_ZN11xercesc_3_212ArrayJanitorIcED2Ev:
  120|  50.7k|{
  121|  50.7k|	reset();
  122|  50.7k|}
_ZN11xercesc_3_212ArrayJanitorIcE5resetEPc:
  162|  50.7k|{
  163|  50.7k|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 9.68k, False: 41.0k]
  ------------------
  164|       |
  165|  9.68k|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 9.68k, False: 0]
  ------------------
  166|  9.68k|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|  9.68k|    }
  170|       |
  171|  50.7k|	fData = p;
  172|  50.7k|    fMemoryManager = 0;
  173|  50.7k|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_12KVStringPairEEEEC2EPS4_PNS_13MemoryManagerE:
  115|      4|{
  116|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_12KVStringPairEEEE7releaseEv:
  153|      4|{
  154|      4|	T* p = fData;
  155|      4|	fData = 0;
  156|      4|	return p;
  157|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_12KVStringPairEEEED2Ev:
  120|      4|{
  121|      4|	reset();
  122|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_12KVStringPairEEEE5resetEPS4_:
  162|      4|{
  163|      4|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 4]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|      4|	fData = p;
  172|      4|    fMemoryManager = 0;
  173|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemINS_7XSValue8DataTypeEEEEC2EPS5_PNS_13MemoryManagerE:
  115|      1|{
  116|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemINS_7XSValue8DataTypeEEEE7releaseEv:
  153|      1|{
  154|      1|	T* p = fData;
  155|      1|	fData = 0;
  156|      1|	return p;
  157|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemINS_7XSValue8DataTypeEEEED2Ev:
  120|      1|{
  121|      1|	reset();
  122|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemINS_7XSValue8DataTypeEEEE5resetEPS5_:
  162|      1|{
  163|      1|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 1]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|      1|	fData = p;
  172|      1|    fMemoryManager = 0;
  173|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_7XMLAttrEEC2EPS1_MS1_FvvE:
  200|  3.11k|{
  201|  3.11k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_7XMLAttrEED2Ev:
  205|  3.11k|{
  206|  3.11k|  reset ();
  207|  3.11k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_7XMLAttrEE5resetEPS1_:
  240|  3.11k|{
  241|  3.11k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 3.11k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  3.11k|  fObject = p;
  245|  3.11k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_7XMLAttrEE7releaseEv:
  232|  3.11k|{
  233|  3.11k|  T* p = fObject;
  234|  3.11k|  fObject = 0;
  235|  3.11k|  return p;
  236|  3.11k|}
_ZN11xercesc_3_27JanitorINS_14BinInputStreamEEC2EPS1_:
   37|  8.52k|{
   38|  8.52k|}
_ZN11xercesc_3_27JanitorINS_14BinInputStreamEED2Ev:
   42|  8.52k|{
   43|  8.52k|    reset();
   44|  8.52k|}
_ZN11xercesc_3_27JanitorINS_14BinInputStreamEE5resetEPS1_:
   88|  8.52k|{
   89|  8.52k|    if (fData)
  ------------------
  |  Branch (89:9): [True: 12, False: 8.51k]
  ------------------
   90|     12|        delete fData;
   91|       |
   92|  8.52k|    fData = p;
   93|  8.52k|}
_ZN11xercesc_3_27JanitorINS_14BinInputStreamEE7releaseEv:
   80|  8.51k|{
   81|  8.51k|	T* p = fData;
   82|  8.51k|	fData = 0;
   83|  8.51k|	return p;
   84|  8.51k|}
_ZN11xercesc_3_27JanitorINS_11InputSourceEEC2EPS1_:
   37|  4.48k|{
   38|  4.48k|}
_ZN11xercesc_3_27JanitorINS_11InputSourceEED2Ev:
   42|  4.48k|{
   43|  4.48k|    reset();
   44|  4.48k|}
_ZN11xercesc_3_27JanitorINS_11InputSourceEE5resetEPS1_:
   88|  6.49k|{
   89|  6.49k|    if (fData)
  ------------------
  |  Branch (89:9): [True: 2.38k, False: 4.10k]
  ------------------
   90|  2.38k|        delete fData;
   91|       |
   92|  6.49k|    fData = p;
   93|  6.49k|}
_ZN11xercesc_3_27JanitorINS_11InputSourceEE6orphanEv:
   52|  2.09k|{
   53|  2.09k|   release();
   54|  2.09k|}
_ZN11xercesc_3_27JanitorINS_11InputSourceEE7releaseEv:
   80|  2.09k|{
   81|  2.09k|	T* p = fData;
   82|  2.09k|	fData = 0;
   83|  2.09k|	return p;
   84|  2.09k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_10XMLScannerEEC2EPS1_MS1_FvvE:
  200|  8.51k|{
  201|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_10XMLScannerEED2Ev:
  205|  8.51k|{
  206|  8.51k|  reset ();
  207|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_10XMLScannerEE5resetEPS1_:
  240|  8.51k|{
  241|  8.51k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 8.51k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  8.51k|  fObject = p;
  245|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_10XMLScannerEE7releaseEv:
  232|  8.51k|{
  233|  8.51k|  T* p = fObject;
  234|  8.51k|  fObject = 0;
  235|  8.51k|  return p;
  236|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9ReaderMgrEEC2EPS1_MS1_FvvE:
  200|  8.51k|{
  201|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9ReaderMgrEED2Ev:
  205|  8.51k|{
  206|  8.51k|  reset ();
  207|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9ReaderMgrEE5resetEPS1_:
  240|  8.51k|{
  241|  8.51k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 8.51k, False: 0]
  |  Branch (241:23): [True: 8.51k, False: 0]
  ------------------
  242|  8.51k|    (fObject->*fToCall)();
  243|       |
  244|  8.51k|  fObject = p;
  245|  8.51k|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemIbEEEC2EPS3_PNS_13MemoryManagerE:
  115|      4|{
  116|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemIbEEE7releaseEv:
  153|      4|{
  154|      4|	T* p = fData;
  155|      4|	fData = 0;
  156|      4|	return p;
  157|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemIbEEED2Ev:
  120|      4|{
  121|      4|	reset();
  122|      4|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemIbEEE5resetEPS3_:
  162|      4|{
  163|      4|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 4]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|      4|	fData = p;
  172|      4|    fMemoryManager = 0;
  173|      4|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9SAXParserEEC2EPS1_MS1_FvvE:
  200|  17.0k|{
  201|  17.0k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9SAXParserEED2Ev:
  205|  17.0k|{
  206|  17.0k|  reset ();
  207|  17.0k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9SAXParserEE5resetEPS1_:
  240|  17.0k|{
  241|  17.0k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 8.51k, False: 8.51k]
  |  Branch (241:23): [True: 8.51k, False: 0]
  ------------------
  242|  8.51k|    (fObject->*fToCall)();
  243|       |
  244|  17.0k|  fObject = p;
  245|  17.0k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_9SAXParserEE7releaseEv:
  232|  8.51k|{
  233|  8.51k|  T* p = fObject;
  234|  8.51k|  fObject = 0;
  235|  8.51k|  return p;
  236|  8.51k|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17DatatypeValidatorEEEEC2EPS4_PNS_13MemoryManagerE:
  115|      2|{
  116|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17DatatypeValidatorEEEE7releaseEv:
  153|      2|{
  154|      2|	T* p = fData;
  155|      2|	fData = 0;
  156|      2|	return p;
  157|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17DatatypeValidatorEEEED2Ev:
  120|      2|{
  121|      2|	reset();
  122|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17DatatypeValidatorEEEE5resetEPS4_:
  162|      2|{
  163|      2|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 2]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|      2|	fData = p;
  172|      2|    fMemoryManager = 0;
  173|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_14DTDElementDeclEEEEC2EPS4_PNS_13MemoryManagerE:
  115|    115|{
  116|    115|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_14DTDElementDeclEEEE7releaseEv:
  153|    115|{
  154|    115|	T* p = fData;
  155|    115|	fData = 0;
  156|    115|	return p;
  157|    115|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_14DTDElementDeclEEEED2Ev:
  120|    115|{
  121|    115|	reset();
  122|    115|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_14DTDElementDeclEEEE5resetEPS4_:
  162|    115|{
  163|    115|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 115]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|    115|	fData = p;
  172|    115|    fMemoryManager = 0;
  173|    115|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemItEEEC2EPS3_PNS_13MemoryManagerE:
  115|      2|{
  116|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemItEEE7releaseEv:
  153|      2|{
  154|      2|	T* p = fData;
  155|      2|	fData = 0;
  156|      2|	return p;
  157|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemItEEED2Ev:
  120|      2|{
  121|      2|	reset();
  122|      2|}
_ZN11xercesc_3_212ArrayJanitorIPNS_24ValueHashTableBucketElemItEEE5resetEPS3_:
  162|      2|{
  163|      2|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 2]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|      2|	fData = p;
  172|      2|    fMemoryManager = 0;
  173|      2|}
_ZN11xercesc_3_212ArrayJanitorIDsEC2EPDs:
  107|  10.6k|{
  108|  10.6k|}
_ZN11xercesc_3_212ArrayJanitorIDsEC2EPDsPNS_13MemoryManagerE:
  115|  23.9k|{
  116|  23.9k|}
_ZN11xercesc_3_212ArrayJanitorIDsED2Ev:
  120|  34.5k|{
  121|  34.5k|	reset();
  122|  34.5k|}
_ZNK11xercesc_3_212ArrayJanitorIDsE3getEv:
  146|    422|{
  147|    422|	return fData;
  148|    422|}
_ZN11xercesc_3_212ArrayJanitorIDsE5resetEPDs:
  162|  34.5k|{
  163|  34.5k|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 23.0k, False: 11.5k]
  ------------------
  164|       |
  165|  23.0k|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 23.0k, False: 0]
  ------------------
  166|  23.0k|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|  23.0k|    }
  170|       |
  171|  34.5k|	fData = p;
  172|  34.5k|    fMemoryManager = 0;
  173|  34.5k|}
_ZN11xercesc_3_212ArrayJanitorIDsE5resetEPDsPNS_13MemoryManagerE:
  177|    422|{
  178|    422|	if (fData) {
  ------------------
  |  Branch (178:6): [True: 0, False: 422]
  ------------------
  179|       |
  180|      0|		if (fMemoryManager)
  ------------------
  |  Branch (180:7): [True: 0, False: 0]
  ------------------
  181|      0|            fMemoryManager->deallocate((void*)fData);
  182|      0|        else
  183|      0|            delete [] fData;
  184|      0|    }
  185|       |
  186|    422|	fData = p;
  187|    422|    fMemoryManager = manager;
  188|    422|}
_ZN11xercesc_3_217JanitorMemFunCallINS_5QNameEEC2EPS1_MS1_FvvE:
  200|  58.1k|{
  201|  58.1k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_5QNameEED2Ev:
  205|  58.1k|{
  206|  58.1k|  reset ();
  207|  58.1k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_5QNameEE5resetEPS1_:
  240|  58.1k|{
  241|  58.1k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 58.1k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  58.1k|  fObject = p;
  245|  58.1k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_5QNameEE7releaseEv:
  232|  58.1k|{
  233|  58.1k|  T* p = fObject;
  234|  58.1k|  fObject = 0;
  235|  58.1k|  return p;
  236|  58.1k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13RangeTokenMapEEC2EPS1_MS1_FvvE:
  200|      1|{
  201|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13RangeTokenMapEED2Ev:
  205|      1|{
  206|      1|  reset ();
  207|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13RangeTokenMapEE5resetEPS1_:
  240|      1|{
  241|      1|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 1]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|      1|  fObject = p;
  245|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13RangeTokenMapEE7releaseEv:
  232|      1|{
  233|      1|  T* p = fObject;
  234|      1|  fObject = 0;
  235|      1|  return p;
  236|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17RangeTokenElemMapEEEEC2EPS4_PNS_13MemoryManagerE:
  115|      1|{
  116|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17RangeTokenElemMapEEEE7releaseEv:
  153|      1|{
  154|      1|	T* p = fData;
  155|      1|	fData = 0;
  156|      1|	return p;
  157|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17RangeTokenElemMapEEEED2Ev:
  120|      1|{
  121|      1|	reset();
  122|      1|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_17RangeTokenElemMapEEEE5resetEPS4_:
  162|      1|{
  163|      1|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 1]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|      1|	fData = p;
  172|      1|    fMemoryManager = 0;
  173|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17RegularExpressionEEC2EPS1_MS1_FvvE:
  200|      4|{
  201|      4|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17RegularExpressionEED2Ev:
  205|      4|{
  206|      4|  reset ();
  207|      4|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17RegularExpressionEE5resetEPS1_:
  240|      4|{
  241|      4|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 4]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|      4|  fObject = p;
  245|      4|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17RegularExpressionEE7releaseEv:
  232|      4|{
  233|      4|  T* p = fObject;
  234|      4|  fObject = 0;
  235|      4|  return p;
  236|      4|}
_ZN11xercesc_3_27JanitorINS_10RegxParserEEC2EPS1_:
   37|      4|{
   38|      4|}
_ZN11xercesc_3_27JanitorINS_10RegxParserEED2Ev:
   42|      4|{
   43|      4|    reset();
   44|      4|}
_ZN11xercesc_3_27JanitorINS_10RegxParserEE5resetEPS1_:
   88|      4|{
   89|      4|    if (fData)
  ------------------
  |  Branch (89:9): [True: 4, False: 0]
  ------------------
   90|      4|        delete fData;
   91|       |
   92|      4|    fData = p;
   93|      4|}
_ZN11xercesc_3_27JanitorINS_12ValueStackOfINS_17RE_RuntimeContextEEEEC2EPS3_:
   37|    159|{
   38|    159|}
_ZN11xercesc_3_27JanitorINS_12ValueStackOfINS_17RE_RuntimeContextEEEED2Ev:
   42|    159|{
   43|    159|    reset();
   44|    159|}
_ZN11xercesc_3_27JanitorINS_12ValueStackOfINS_17RE_RuntimeContextEEEE5resetEPS3_:
   88|    159|{
   89|    159|    if (fData)
  ------------------
  |  Branch (89:9): [True: 0, False: 159]
  ------------------
   90|      0|        delete fData;
   91|       |
   92|    159|    fData = p;
   93|    159|}
_ZN11xercesc_3_212ArrayJanitorIiEC2EPiPNS_13MemoryManagerE:
  115|      1|{
  116|      1|}
_ZN11xercesc_3_212ArrayJanitorIiED2Ev:
  120|      1|{
  121|      1|	reset();
  122|      1|}
_ZN11xercesc_3_212ArrayJanitorIiE5resetEPi:
  162|      1|{
  163|      1|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 1, False: 0]
  ------------------
  164|       |
  165|      1|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 1, False: 0]
  ------------------
  166|      1|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      1|    }
  170|       |
  171|      1|	fData = p;
  172|      1|    fMemoryManager = 0;
  173|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLBigDecimalEEC2EPS1_MS1_FvvE:
  200|     32|{
  201|     32|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLBigDecimalEED2Ev:
  205|     32|{
  206|     32|  reset ();
  207|     32|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLBigDecimalEE5resetEPS1_:
  240|     32|{
  241|     32|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 32]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|     32|  fObject = p;
  245|     32|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLBigDecimalEE7releaseEv:
  232|     32|{
  233|     32|  T* p = fObject;
  234|     32|  fObject = 0;
  235|     32|  return p;
  236|     32|}
_ZN11xercesc_3_217JanitorMemFunCallINS_18XMLStringTokenizerEEC2EPS1_MS1_FvvE:
  200|      1|{
  201|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_18XMLStringTokenizerEED2Ev:
  205|      1|{
  206|      1|  reset ();
  207|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_18XMLStringTokenizerEE5resetEPS1_:
  240|      1|{
  241|      1|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 1]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|      1|  fObject = p;
  245|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_18XMLStringTokenizerEE7releaseEv:
  232|      1|{
  233|      1|  T* p = fObject;
  234|      1|  fObject = 0;
  235|      1|  return p;
  236|      1|}
_ZN11xercesc_3_217JanitorMemFunCallINS_6XMLURLEEC2EPS1_MS1_FvvE:
  200|    239|{
  201|    239|}
_ZN11xercesc_3_217JanitorMemFunCallINS_6XMLURLEED2Ev:
  205|    239|{
  206|    239|  reset ();
  207|    239|}
_ZN11xercesc_3_217JanitorMemFunCallINS_6XMLURLEE5resetEPS1_:
  240|    239|{
  241|    239|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 239]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|    239|  fObject = p;
  245|    239|}
_ZN11xercesc_3_217JanitorMemFunCallINS_6XMLURLEE7releaseEv:
  232|    239|{
  233|    239|  T* p = fObject;
  234|    239|  fObject = 0;
  235|    239|  return p;
  236|    239|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLEntityDeclEEC2EPS1_MS1_FvvE:
  200|      5|{
  201|      5|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLEntityDeclEED2Ev:
  205|      5|{
  206|      5|  reset ();
  207|      5|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLEntityDeclEE5resetEPS1_:
  240|      5|{
  241|      5|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 5]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|      5|  fObject = p;
  245|      5|}
_ZN11xercesc_3_217JanitorMemFunCallINS_13XMLEntityDeclEE7releaseEv:
  232|      5|{
  233|      5|  T* p = fObject;
  234|      5|  fObject = 0;
  235|      5|  return p;
  236|      5|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15XMLNotationDeclEEC2EPS1_MS1_FvvE:
  200|  1.86k|{
  201|  1.86k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15XMLNotationDeclEED2Ev:
  205|  1.86k|{
  206|  1.86k|  reset ();
  207|  1.86k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15XMLNotationDeclEE5resetEPS1_:
  240|  1.86k|{
  241|  1.86k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 1.86k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  1.86k|  fObject = p;
  245|  1.86k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15XMLNotationDeclEE7releaseEv:
  232|  1.86k|{
  233|  1.86k|  T* p = fObject;
  234|  1.86k|  fObject = 0;
  235|  1.86k|  return p;
  236|  1.86k|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLRefInfoEEEEC2EPS4_PNS_13MemoryManagerE:
  115|     39|{
  116|     39|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLRefInfoEEEE7releaseEv:
  153|     39|{
  154|     39|	T* p = fData;
  155|     39|	fData = 0;
  156|     39|	return p;
  157|     39|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLRefInfoEEEED2Ev:
  120|     39|{
  121|     39|	reset();
  122|     39|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLRefInfoEEEE5resetEPS4_:
  162|     39|{
  163|     39|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 39]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|     39|	fData = p;
  172|     39|    fMemoryManager = 0;
  173|     39|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_9DTDAttDefEEEEC2EPS4_PNS_13MemoryManagerE:
  115|    198|{
  116|    198|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_9DTDAttDefEEEE7releaseEv:
  153|    198|{
  154|    198|	T* p = fData;
  155|    198|	fData = 0;
  156|    198|	return p;
  157|    198|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_9DTDAttDefEEEED2Ev:
  120|    198|{
  121|    198|	reset();
  122|    198|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_9DTDAttDefEEEE5resetEPS4_:
  162|    198|{
  163|    198|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 198]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|    198|	fData = p;
  172|    198|    fMemoryManager = 0;
  173|    198|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLIntegerEEEEC2EPS4_PNS_13MemoryManagerE:
  115|    185|{
  116|    185|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLIntegerEEEE7releaseEv:
  153|    185|{
  154|    185|	T* p = fData;
  155|    185|	fData = 0;
  156|    185|	return p;
  157|    185|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLIntegerEEEED2Ev:
  120|    185|{
  121|    185|	reset();
  122|    185|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22RefHashTableBucketElemINS_10XMLIntegerEEEE5resetEPS4_:
  162|    185|{
  163|    185|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 185]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|    185|	fData = p;
  172|    185|    fMemoryManager = 0;
  173|    185|}
_ZN11xercesc_3_27JanitorINS_14DTDElementDeclEEC2EPS1_:
   37|  8.30k|{
   38|  8.30k|}
_ZN11xercesc_3_27JanitorINS_14DTDElementDeclEED2Ev:
   42|  8.30k|{
   43|  8.30k|    reset();
   44|  8.30k|}
_ZN11xercesc_3_27JanitorINS_14DTDElementDeclEE5resetEPS1_:
   88|  8.30k|{
   89|  8.30k|    if (fData)
  ------------------
  |  Branch (89:9): [True: 0, False: 8.30k]
  ------------------
   90|      0|        delete fData;
   91|       |
   92|  8.30k|    fData = p;
   93|  8.30k|}
_ZN11xercesc_3_27JanitorINS_14DTDElementDeclEE7releaseEv:
   80|  8.30k|{
   81|  8.30k|	T* p = fData;
   82|  8.30k|	fData = 0;
   83|  8.30k|	return p;
   84|  8.30k|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22Hash2KeysSetBucketElemEEC2EPS2_PNS_13MemoryManagerE:
  115|     13|{
  116|     13|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22Hash2KeysSetBucketElemEE7releaseEv:
  153|     13|{
  154|     13|	T* p = fData;
  155|     13|	fData = 0;
  156|     13|	return p;
  157|     13|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22Hash2KeysSetBucketElemEED2Ev:
  120|     13|{
  121|     13|	reset();
  122|     13|}
_ZN11xercesc_3_212ArrayJanitorIPNS_22Hash2KeysSetBucketElemEE5resetEPS2_:
  162|     13|{
  163|     13|	if (fData) {
  ------------------
  |  Branch (163:6): [True: 0, False: 13]
  ------------------
  164|       |
  165|      0|		if (fMemoryManager)
  ------------------
  |  Branch (165:7): [True: 0, False: 0]
  ------------------
  166|      0|            fMemoryManager->deallocate((void*)fData);
  167|      0|        else
  168|      0|            delete [] fData;
  169|      0|    }
  170|       |
  171|     13|	fData = p;
  172|     13|    fMemoryManager = 0;
  173|     13|}
_ZN11xercesc_3_217JanitorMemFunCallINS_12IGXMLScannerEEC2EPS1_MS1_FvvE:
  200|  8.51k|{
  201|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_12IGXMLScannerEED2Ev:
  205|  8.51k|{
  206|  8.51k|  reset ();
  207|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_12IGXMLScannerEE5resetEPS1_:
  240|  8.51k|{
  241|  8.51k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 8.51k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  8.51k|  fObject = p;
  245|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_12IGXMLScannerEE7releaseEv:
  232|  8.51k|{
  233|  8.51k|  T* p = fObject;
  234|  8.51k|  fObject = 0;
  235|  8.51k|  return p;
  236|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_25IdentityConstraintHandlerEEC2EPS1_MS1_FvvE:
  200|  8.51k|{
  201|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_25IdentityConstraintHandlerEED2Ev:
  205|  8.51k|{
  206|  8.51k|  reset ();
  207|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_25IdentityConstraintHandlerEE5resetEPS1_:
  240|  8.51k|{
  241|  8.51k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 8.51k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  8.51k|  fObject = p;
  245|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_25IdentityConstraintHandlerEE7releaseEv:
  232|  8.51k|{
  233|  8.51k|  T* p = fObject;
  234|  8.51k|  fObject = 0;
  235|  8.51k|  return p;
  236|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15ValueStoreCacheEEC2EPS1_MS1_FvvE:
  200|  8.51k|{
  201|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15ValueStoreCacheEED2Ev:
  205|  8.51k|{
  206|  8.51k|  reset ();
  207|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15ValueStoreCacheEE5resetEPS1_:
  240|  8.51k|{
  241|  8.51k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 8.51k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  8.51k|  fObject = p;
  245|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_15ValueStoreCacheEE7releaseEv:
  232|  8.51k|{
  233|  8.51k|  T* p = fObject;
  234|  8.51k|  fObject = 0;
  235|  8.51k|  return p;
  236|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17XPathMatcherStackEEC2EPS1_MS1_FvvE:
  200|  8.51k|{
  201|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17XPathMatcherStackEED2Ev:
  205|  8.51k|{
  206|  8.51k|  reset ();
  207|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17XPathMatcherStackEE5resetEPS1_:
  240|  8.51k|{
  241|  8.51k|  if (fObject != 0 && fToCall != 0)
  ------------------
  |  Branch (241:7): [True: 0, False: 8.51k]
  |  Branch (241:23): [True: 0, False: 0]
  ------------------
  242|      0|    (fObject->*fToCall)();
  243|       |
  244|  8.51k|  fObject = p;
  245|  8.51k|}
_ZN11xercesc_3_217JanitorMemFunCallINS_17XPathMatcherStackEE7releaseEv:
  232|  8.51k|{
  233|  8.51k|  T* p = fObject;
  234|  8.51k|  fObject = 0;
  235|  8.51k|  return p;
  236|  8.51k|}

_ZN11xercesc_3_212KVStringPairC2EPKDsS2_PNS_13MemoryManagerE:
   51|     26|{
   52|     26|   set(key, value);
   53|     26|}
_ZN11xercesc_3_212KVStringPairC2ERKS0_:
   92|     26|{
   93|     26|   set(toCopy.fKey, toCopy.fValue);
   94|     26|}
_ZN11xercesc_3_212KVStringPairD2Ev:
   97|     26|{
   98|     26|    fMemoryManager->deallocate(fKey); //delete [] fKey;
   99|     26|    fMemoryManager->deallocate(fValue); //delete [] fValue;
  100|     26|}

_ZN11xercesc_3_212KVStringPair6getKeyEv:
  149|     26|{
  150|     26|    return fKey;
  151|     26|}
_ZN11xercesc_3_212KVStringPair8getValueEv:
  159|     26|{
  160|     26|    return fValue;
  161|     26|}
_ZN11xercesc_3_212KVStringPair6setKeyEPKDsm:
  178|     52|{
  179|     52|    if (newKeyLength >= fKeyAllocSize)
  ------------------
  |  Branch (179:9): [True: 52, False: 0]
  ------------------
  180|     52|    {
  181|     52|        fMemoryManager->deallocate(fKey); //delete [] fKey;
  182|     52|        fKey = 0;
  183|     52|        fKeyAllocSize = newKeyLength + 1;
  184|     52|        fKey = (XMLCh*) fMemoryManager->allocate(fKeyAllocSize * sizeof(XMLCh)); //new XMLCh[fKeyAllocSize];
  185|     52|    }
  186|       |
  187|     52|    memcpy(fKey, newKey, (newKeyLength+1) * sizeof(XMLCh)); // len+1 because of the 0 at the end
  188|     52|}
_ZN11xercesc_3_212KVStringPair8setValueEPKDsm:
  192|     52|{
  193|     52|    if (newValueLength >= fValueAllocSize)
  ------------------
  |  Branch (193:9): [True: 52, False: 0]
  ------------------
  194|     52|    {
  195|     52|        fMemoryManager->deallocate(fValue); //delete [] fValue;
  196|     52|        fValue = 0;
  197|     52|        fValueAllocSize = newValueLength + 1;
  198|     52|        fValue = (XMLCh*) fMemoryManager->allocate(fValueAllocSize * sizeof(XMLCh)); //new XMLCh[fValueAllocSize];
  199|     52|    }
  200|       |
  201|     52|    memcpy(fValue, newValue, (newValueLength+1) * sizeof(XMLCh)); // len+1 because of the 0 at the end
  202|     52|}
_ZN11xercesc_3_212KVStringPair3setEPKDsS2_:
  206|     52|{
  207|     52|    setKey(newKey, XMLString::stringLen(newKey));
  208|     52|    setValue(newValue, XMLString::stringLen(newValue));
  209|     52|}

_ZN11xercesc_3_214InMemMsgLoaderC2EPKDs:
   41|      8|{
   42|      8|    if (!XMLString::equals(msgDomain, XMLUni::fgXMLErrDomain)
  ------------------
  |  Branch (42:9): [True: 4, False: 4]
  ------------------
   43|      8|    &&  !XMLString::equals(msgDomain, XMLUni::fgExceptDomain)
  ------------------
  |  Branch (43:9): [True: 3, False: 1]
  ------------------
   44|      8|    &&  !XMLString::equals(msgDomain, XMLUni::fgXMLDOMMsgDomain)
  ------------------
  |  Branch (44:9): [True: 2, False: 1]
  ------------------
   45|      8|    &&  !XMLString::equals(msgDomain, XMLUni::fgValidityDomain))
  ------------------
  |  Branch (45:9): [True: 0, False: 2]
  ------------------
   46|      0|    {
   47|      0|        XMLPlatformUtils::panic(PanicHandler::Panic_UnknownMsgDomain);
   48|      0|    }
   49|       |
   50|      8|    fMsgDomain = XMLString::replicate(msgDomain, XMLPlatformUtils::fgMemoryManager);
   51|      8|}
_ZN11xercesc_3_214InMemMsgLoader7loadMsgEjPDsm:
   65|  2.95k|{
   66|       |    //
   67|       |    //  Just use the id to map into the correct array of messages. Then
   68|       |    //  copy that to the caller's buffer.
   69|       |    //
   70|       |    //  NOTE:   The source text is in little endian form. So, if we are a
   71|       |    //          big endian machine, flip them in the process.
   72|       |    //
   73|  2.95k|    XMLCh* endPtr = toFill + maxChars;
   74|  2.95k|    XMLCh* outPtr = toFill;
   75|  2.95k|    const XMLCh* srcPtr = 0;
   76|       |
   77|  2.95k|    if (XMLString::equals(fMsgDomain, XMLUni::fgXMLErrDomain))
  ------------------
  |  Branch (77:9): [True: 0, False: 2.95k]
  ------------------
   78|      0|    {
   79|      0|        if ( msgToLoad > gXMLErrArraySize)
  ------------------
  |  Branch (79:14): [True: 0, False: 0]
  ------------------
   80|      0|            return false;
   81|      0|        else
   82|      0|            srcPtr = gXMLErrArray[msgToLoad - 1];
   83|      0|    }
   84|  2.95k|     else if (XMLString::equals(fMsgDomain, XMLUni::fgExceptDomain))
  ------------------
  |  Branch (84:15): [True: 2.95k, False: 0]
  ------------------
   85|  2.95k|    {
   86|  2.95k|         if ( msgToLoad > gXMLExceptArraySize)
  ------------------
  |  Branch (86:15): [True: 0, False: 2.95k]
  ------------------
   87|      0|            return false;
   88|  2.95k|         else
   89|  2.95k|             srcPtr = gXMLExceptArray[msgToLoad - 1];
   90|  2.95k|    }
   91|      0|     else if (XMLString::equals(fMsgDomain, XMLUni::fgValidityDomain))
  ------------------
  |  Branch (91:15): [True: 0, False: 0]
  ------------------
   92|      0|    {
   93|      0|         if ( msgToLoad > gXMLValidityArraySize)
  ------------------
  |  Branch (93:15): [True: 0, False: 0]
  ------------------
   94|      0|            return false;
   95|      0|         else
   96|      0|             srcPtr = gXMLValidityArray[msgToLoad - 1];
   97|      0|    }
   98|      0|     else if (XMLString::equals(fMsgDomain, XMLUni::fgXMLDOMMsgDomain))
  ------------------
  |  Branch (98:15): [True: 0, False: 0]
  ------------------
   99|      0|    {
  100|      0|         if ( msgToLoad > gXMLDOMMsgArraySize)
  ------------------
  |  Branch (100:15): [True: 0, False: 0]
  ------------------
  101|      0|            return false;
  102|      0|         else
  103|      0|             srcPtr = gXMLDOMMsgArray[msgToLoad - 1];
  104|      0|    } else {
  105|      0|	return false;
  106|      0|    }
  107|       |
  108|   106k|     while (*srcPtr && (outPtr < endPtr))
  ------------------
  |  Branch (108:13): [True: 103k, False: 2.95k]
  |  Branch (108:24): [True: 103k, False: 0]
  ------------------
  109|   103k|     {
  110|   103k|         *outPtr++ = *srcPtr++;
  111|   103k|     }
  112|  2.95k|     *outPtr = 0;
  113|       |
  114|  2.95k|     return true;
  115|  2.95k|}
_ZN11xercesc_3_214InMemMsgLoader7loadMsgEjPDsmPKDsS3_S3_S3_PNS_13MemoryManagerE:
  126|  2.60k|{
  127|       |    // Call the other version to load up the message
  128|  2.60k|    if (!loadMsg(msgToLoad, toFill, maxChars))
  ------------------
  |  Branch (128:9): [True: 0, False: 2.60k]
  ------------------
  129|      0|        return false;
  130|       |
  131|       |    // And do the token replacement
  132|  2.60k|    XMLString::replaceTokens(toFill, maxChars, repText1, repText2, repText3, repText4, manager);
  133|  2.60k|    return true;
  134|  2.60k|}
_ZN11xercesc_3_214InMemMsgLoader7loadMsgEjPDsmPKcS3_S3_S3_PNS_13MemoryManagerE:
  145|    290|{
  146|       |    //
  147|       |    //  Transcode the provided parameters and call the other version,
  148|       |    //  which will do the replacement work.
  149|       |    //
  150|    290|    XMLCh* tmp1 = 0;
  151|    290|    XMLCh* tmp2 = 0;
  152|    290|    XMLCh* tmp3 = 0;
  153|    290|    XMLCh* tmp4 = 0;
  154|       |    
  155|    290|    bool bRet = false;
  156|    290|    if (repText1)
  ------------------
  |  Branch (156:9): [True: 290, False: 0]
  ------------------
  157|    290|        tmp1 = XMLString::transcode(repText1, manager);
  158|    290|    if (repText2)
  ------------------
  |  Branch (158:9): [True: 290, False: 0]
  ------------------
  159|    290|        tmp2 = XMLString::transcode(repText2, manager);
  160|    290|    if (repText3)
  ------------------
  |  Branch (160:9): [True: 231, False: 59]
  ------------------
  161|    231|        tmp3 = XMLString::transcode(repText3, manager);
  162|    290|    if (repText4)
  ------------------
  |  Branch (162:9): [True: 0, False: 290]
  ------------------
  163|      0|        tmp4 = XMLString::transcode(repText4, manager);
  164|       |
  165|    290|    bRet = loadMsg(msgToLoad, toFill, maxChars, tmp1, tmp2, tmp3, tmp4, manager);
  166|       |
  167|    290|    if (tmp1)
  ------------------
  |  Branch (167:9): [True: 290, False: 0]
  ------------------
  168|    290|        manager->deallocate(tmp1);//delete [] tmp1;
  169|    290|    if (tmp2)
  ------------------
  |  Branch (169:9): [True: 290, False: 0]
  ------------------
  170|    290|        manager->deallocate(tmp2);//delete [] tmp2;
  171|    290|    if (tmp3)
  ------------------
  |  Branch (171:9): [True: 231, False: 59]
  ------------------
  172|    231|        manager->deallocate(tmp3);//delete [] tmp3;
  173|    290|    if (tmp4)
  ------------------
  |  Branch (173:9): [True: 0, False: 290]
  ------------------
  174|      0|        manager->deallocate(tmp4);//delete [] tmp4;
  175|       |
  176|    290|    return bRet;
  177|    290|}

_ZN11xercesc_3_211StdMutexMgrC2Ev:
   40|      1|{
   41|      1|}
_ZN11xercesc_3_211StdMutexMgr6createEPNS_13MemoryManagerE:
   51|  7.26k|{
   52|  7.26k|    StdMutexWrap* mutex = new (manager) StdMutexWrap;
   53|  7.26k|    return (void*)(mutex);
   54|  7.26k|}
_ZN11xercesc_3_211StdMutexMgr7destroyEPvPNS_13MemoryManagerE:
   59|  7.25k|{
   60|  7.25k|    StdMutexWrap* mutex = (StdMutexWrap*)(mtx);
   61|  7.25k|    if (mutex != NULL)
  ------------------
  |  Branch (61:9): [True: 7.25k, False: 0]
  ------------------
   62|  7.25k|    {
   63|  7.25k|        delete mutex;
   64|  7.25k|    }
   65|  7.25k|}
_ZN11xercesc_3_211StdMutexMgr4lockEPv:
   70|  58.8k|{
   71|  58.8k|    StdMutexWrap* mutex = (StdMutexWrap*)(mtx);
   72|  58.8k|    if (mutex != NULL)
  ------------------
  |  Branch (72:9): [True: 58.8k, False: 0]
  ------------------
   73|  58.8k|    {
   74|  58.8k|        mutex->m.lock();
   75|  58.8k|    }
   76|  58.8k|}
_ZN11xercesc_3_211StdMutexMgr6unlockEPv:
   81|  58.8k|{
   82|  58.8k|    StdMutexWrap* mutex = (StdMutexWrap*)(mtx);
   83|  58.8k|    if (mutex != NULL)
  ------------------
  |  Branch (83:9): [True: 58.8k, False: 0]
  ------------------
   84|  58.8k|    {
   85|  58.8k|        mutex->m.unlock();
   86|  58.8k|    }
   87|  58.8k|}

_ZN11xercesc_3_28XMLMutexC2EPNS_13MemoryManagerE:
   40|  7.26k|{
   41|       |    // Ask the per-platform driver to make us a mutex
   42|  7.26k|    fHandle = XMLPlatformUtils::makeMutex(manager);
   43|  7.26k|}
_ZN11xercesc_3_28XMLMutexD2Ev:
   47|  7.25k|{
   48|  7.25k|    if (fHandle)
  ------------------
  |  Branch (48:9): [True: 7.25k, False: 0]
  ------------------
   49|  7.25k|    {
   50|  7.25k|        XMLPlatformUtils::closeMutex(fHandle, fManager);
   51|  7.25k|        fHandle = 0;
   52|  7.25k|    }
   53|  7.25k|}
_ZN11xercesc_3_28XMLMutex4lockEv:
   60|  58.8k|{
   61|  58.8k|    XMLPlatformUtils::lockMutex(fHandle);
   62|  58.8k|}
_ZN11xercesc_3_28XMLMutex6unlockEv:
   65|  58.8k|{
   66|  58.8k|    XMLPlatformUtils::unlockMutex(fHandle);
   67|  58.8k|}
_ZN11xercesc_3_212XMLMutexLockC2EPNS_8XMLMutexE:
   77|  58.8k|{
   78|  58.8k|    fToLock->lock();
   79|  58.8k|}
_ZN11xercesc_3_212XMLMutexLockD2Ev:
   83|  58.8k|{
   84|  58.8k|    fToLock->unlock();
   85|  58.8k|}

_ZN11xercesc_3_210NameIdPoolINS_15XMLNotationDeclEE8getByKeyEPKDs:
  107|  3.04k|{
  108|  3.04k|    if (fIdCounter == 0) return 0;
  ------------------
  |  Branch (108:9): [True: 1.56k, False: 1.47k]
  ------------------
  109|  1.47k|    return fBucketList.get(key);
  110|  3.04k|}
_ZN11xercesc_3_210NameIdPoolINS_15XMLNotationDeclEE3putEPS1_:
  153|  1.86k|{
  154|       |    // First see if the key exists already. If so, its an error
  155|  1.86k|    if(containsKey(elemToAdopt->getKey()))
  ------------------
  |  Branch (155:8): [True: 0, False: 1.86k]
  ------------------
  156|      0|    {
  157|      0|        ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  158|      0|        (
  159|      0|            IllegalArgumentException
  160|      0|            , XMLExcepts::Pool_ElemAlreadyExists
  161|      0|            , elemToAdopt->getKey()
  162|      0|            , fMemoryManager
  163|      0|        );
  164|      0|    }
  165|       |
  166|  1.86k|    fBucketList.put((void*)elemToAdopt->getKey(), elemToAdopt);
  167|       |
  168|       |    //
  169|       |    //  Give this new one the next available id and add to the pointer list.
  170|       |    //  Expand the list if that is now required.
  171|       |    //
  172|  1.86k|    if (fIdCounter + 1 == fIdPtrsCount)
  ------------------
  |  Branch (172:9): [True: 0, False: 1.86k]
  ------------------
  173|      0|    {
  174|       |        // Create a new count 1.5 times larger and allocate a new array
  175|      0|        XMLSize_t newCount = (XMLSize_t)(fIdPtrsCount * 1.5);
  176|      0|        TElem** newArray = (TElem**) fMemoryManager->allocate
  177|      0|        (
  178|      0|            newCount * sizeof(TElem*)
  179|      0|        ); //new TElem*[newCount];
  180|       |
  181|       |        // Copy over the old contents to the new array
  182|      0|        memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TElem*));
  183|       |
  184|       |        // Ok, toss the old array and store the new data
  185|      0|        fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
  186|      0|        fIdPtrs = newArray;
  187|      0|        fIdPtrsCount = newCount;
  188|      0|    }
  189|  1.86k|    const XMLSize_t retId = ++fIdCounter;
  190|  1.86k|    fIdPtrs[retId] = elemToAdopt;
  191|       |
  192|       |    // Set the id on the passed element
  193|  1.86k|    elemToAdopt->setId(retId);
  194|       |
  195|       |    // Return the id that we gave to this element
  196|  1.86k|    return retId;
  197|  1.86k|}
_ZNK11xercesc_3_210NameIdPoolINS_15XMLNotationDeclEE11containsKeyEPKDs:
   84|  1.86k|{
   85|  1.86k|    if (fIdCounter == 0) return false;
  ------------------
  |  Branch (85:9): [True: 1.54k, False: 317]
  ------------------
   86|    317|    return fBucketList.containsKey(key);
   87|  1.86k|}
_ZN11xercesc_3_210NameIdPoolINS_14DTDElementDeclEE8getByKeyEPKDs:
  107|  2.51M|{
  108|  2.51M|    if (fIdCounter == 0) return 0;
  ------------------
  |  Branch (108:9): [True: 2.58k, False: 2.51M]
  ------------------
  109|  2.51M|    return fBucketList.get(key);
  110|  2.51M|}
_ZN11xercesc_3_210NameIdPoolINS_13DTDEntityDeclEE3putEPS1_:
  153|  2.89k|{
  154|       |    // First see if the key exists already. If so, its an error
  155|  2.89k|    if(containsKey(elemToAdopt->getKey()))
  ------------------
  |  Branch (155:8): [True: 0, False: 2.89k]
  ------------------
  156|      0|    {
  157|      0|        ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  158|      0|        (
  159|      0|            IllegalArgumentException
  160|      0|            , XMLExcepts::Pool_ElemAlreadyExists
  161|      0|            , elemToAdopt->getKey()
  162|      0|            , fMemoryManager
  163|      0|        );
  164|      0|    }
  165|       |
  166|  2.89k|    fBucketList.put((void*)elemToAdopt->getKey(), elemToAdopt);
  167|       |
  168|       |    //
  169|       |    //  Give this new one the next available id and add to the pointer list.
  170|       |    //  Expand the list if that is now required.
  171|       |    //
  172|  2.89k|    if (fIdCounter + 1 == fIdPtrsCount)
  ------------------
  |  Branch (172:9): [True: 0, False: 2.89k]
  ------------------
  173|      0|    {
  174|       |        // Create a new count 1.5 times larger and allocate a new array
  175|      0|        XMLSize_t newCount = (XMLSize_t)(fIdPtrsCount * 1.5);
  176|      0|        TElem** newArray = (TElem**) fMemoryManager->allocate
  177|      0|        (
  178|      0|            newCount * sizeof(TElem*)
  179|      0|        ); //new TElem*[newCount];
  180|       |
  181|       |        // Copy over the old contents to the new array
  182|      0|        memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TElem*));
  183|       |
  184|       |        // Ok, toss the old array and store the new data
  185|      0|        fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
  186|      0|        fIdPtrs = newArray;
  187|      0|        fIdPtrsCount = newCount;
  188|      0|    }
  189|  2.89k|    const XMLSize_t retId = ++fIdCounter;
  190|  2.89k|    fIdPtrs[retId] = elemToAdopt;
  191|       |
  192|       |    // Set the id on the passed element
  193|  2.89k|    elemToAdopt->setId(retId);
  194|       |
  195|       |    // Return the id that we gave to this element
  196|  2.89k|    return retId;
  197|  2.89k|}
_ZNK11xercesc_3_210NameIdPoolINS_13DTDEntityDeclEE11containsKeyEPKDs:
   84|  2.89k|{
   85|  2.89k|    if (fIdCounter == 0) return false;
  ------------------
  |  Branch (85:9): [True: 2.27k, False: 617]
  ------------------
   86|    617|    return fBucketList.containsKey(key);
   87|  2.89k|}
_ZN11xercesc_3_210NameIdPoolINS_14DTDElementDeclEEC2EmmPNS_13MemoryManagerE:
   50|  17.0k|{
   51|  17.0k|    if (!hashModulus)
  ------------------
  |  Branch (51:9): [True: 0, False: 17.0k]
  ------------------
   52|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   53|       |
   54|       |    //
   55|       |    //  Allocate the initial id pointers array. We don't have to zero them
   56|       |    //  out since the fIdCounter value tells us which ones are valid. The
   57|       |    //  zeroth element is never used (and represents an invalid pool id.)
   58|       |    //
   59|  17.0k|    if (!fIdPtrsCount)
  ------------------
  |  Branch (59:9): [True: 0, False: 17.0k]
  ------------------
   60|      0|        fIdPtrsCount = 256;
   61|  17.0k|    fIdPtrs = (TElem**) fMemoryManager->allocate
   62|  17.0k|    (
   63|  17.0k|        fIdPtrsCount * sizeof(TElem*)
   64|  17.0k|    );
   65|  17.0k|    fIdPtrs[0] = 0;
   66|  17.0k|}
_ZN11xercesc_3_210NameIdPoolINS_14DTDElementDeclEE3putEPS1_:
  153|  52.6k|{
  154|       |    // First see if the key exists already. If so, its an error
  155|  52.6k|    if(containsKey(elemToAdopt->getKey()))
  ------------------
  |  Branch (155:8): [True: 0, False: 52.6k]
  ------------------
  156|      0|    {
  157|      0|        ThrowXMLwithMemMgr1
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  158|      0|        (
  159|      0|            IllegalArgumentException
  160|      0|            , XMLExcepts::Pool_ElemAlreadyExists
  161|      0|            , elemToAdopt->getKey()
  162|      0|            , fMemoryManager
  163|      0|        );
  164|      0|    }
  165|       |
  166|  52.6k|    fBucketList.put((void*)elemToAdopt->getKey(), elemToAdopt);
  167|       |
  168|       |    //
  169|       |    //  Give this new one the next available id and add to the pointer list.
  170|       |    //  Expand the list if that is now required.
  171|       |    //
  172|  52.6k|    if (fIdCounter + 1 == fIdPtrsCount)
  ------------------
  |  Branch (172:9): [True: 44, False: 52.5k]
  ------------------
  173|     44|    {
  174|       |        // Create a new count 1.5 times larger and allocate a new array
  175|     44|        XMLSize_t newCount = (XMLSize_t)(fIdPtrsCount * 1.5);
  176|     44|        TElem** newArray = (TElem**) fMemoryManager->allocate
  177|     44|        (
  178|     44|            newCount * sizeof(TElem*)
  179|     44|        ); //new TElem*[newCount];
  180|       |
  181|       |        // Copy over the old contents to the new array
  182|     44|        memcpy(newArray, fIdPtrs, fIdPtrsCount * sizeof(TElem*));
  183|       |
  184|       |        // Ok, toss the old array and store the new data
  185|     44|        fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
  186|     44|        fIdPtrs = newArray;
  187|     44|        fIdPtrsCount = newCount;
  188|     44|    }
  189|  52.6k|    const XMLSize_t retId = ++fIdCounter;
  190|  52.6k|    fIdPtrs[retId] = elemToAdopt;
  191|       |
  192|       |    // Set the id on the passed element
  193|  52.6k|    elemToAdopt->setId(retId);
  194|       |
  195|       |    // Return the id that we gave to this element
  196|  52.6k|    return retId;
  197|  52.6k|}
_ZNK11xercesc_3_210NameIdPoolINS_14DTDElementDeclEE11containsKeyEPKDs:
   84|  52.6k|{
   85|  52.6k|    if (fIdCounter == 0) return false;
  ------------------
  |  Branch (85:9): [True: 10.8k, False: 41.7k]
  ------------------
   86|  41.7k|    return fBucketList.containsKey(key);
   87|  52.6k|}
_ZN11xercesc_3_210NameIdPoolINS_13DTDEntityDeclEEC2EmmPNS_13MemoryManagerE:
   50|  16.8k|{
   51|  16.8k|    if (!hashModulus)
  ------------------
  |  Branch (51:9): [True: 0, False: 16.8k]
  ------------------
   52|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   53|       |
   54|       |    //
   55|       |    //  Allocate the initial id pointers array. We don't have to zero them
   56|       |    //  out since the fIdCounter value tells us which ones are valid. The
   57|       |    //  zeroth element is never used (and represents an invalid pool id.)
   58|       |    //
   59|  16.8k|    if (!fIdPtrsCount)
  ------------------
  |  Branch (59:9): [True: 0, False: 16.8k]
  ------------------
   60|      0|        fIdPtrsCount = 256;
   61|  16.8k|    fIdPtrs = (TElem**) fMemoryManager->allocate
   62|  16.8k|    (
   63|  16.8k|        fIdPtrsCount * sizeof(TElem*)
   64|  16.8k|    );
   65|  16.8k|    fIdPtrs[0] = 0;
   66|  16.8k|}
_ZN11xercesc_3_210NameIdPoolINS_13DTDEntityDeclEED2Ev:
   69|  16.8k|{
   70|       |    //
   71|       |    //  Delete the id pointers list. The stuff it points to will be cleaned
   72|       |    //  up when we clean the bucket lists.
   73|       |    //
   74|  16.8k|    fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
   75|  16.8k|}
_ZN11xercesc_3_210NameIdPoolINS_15XMLNotationDeclEEC2EmmPNS_13MemoryManagerE:
   50|  8.51k|{
   51|  8.51k|    if (!hashModulus)
  ------------------
  |  Branch (51:9): [True: 0, False: 8.51k]
  ------------------
   52|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Pool_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   53|       |
   54|       |    //
   55|       |    //  Allocate the initial id pointers array. We don't have to zero them
   56|       |    //  out since the fIdCounter value tells us which ones are valid. The
   57|       |    //  zeroth element is never used (and represents an invalid pool id.)
   58|       |    //
   59|  8.51k|    if (!fIdPtrsCount)
  ------------------
  |  Branch (59:9): [True: 0, False: 8.51k]
  ------------------
   60|      0|        fIdPtrsCount = 256;
   61|  8.51k|    fIdPtrs = (TElem**) fMemoryManager->allocate
   62|  8.51k|    (
   63|  8.51k|        fIdPtrsCount * sizeof(TElem*)
   64|  8.51k|    );
   65|  8.51k|    fIdPtrs[0] = 0;
   66|  8.51k|}
_ZN11xercesc_3_210NameIdPoolINS_14DTDElementDeclEED2Ev:
   69|  17.0k|{
   70|       |    //
   71|       |    //  Delete the id pointers list. The stuff it points to will be cleaned
   72|       |    //  up when we clean the bucket lists.
   73|       |    //
   74|  17.0k|    fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
   75|  17.0k|}
_ZN11xercesc_3_210NameIdPoolINS_15XMLNotationDeclEED2Ev:
   69|  8.51k|{
   70|       |    //
   71|       |    //  Delete the id pointers list. The stuff it points to will be cleaned
   72|       |    //  up when we clean the bucket lists.
   73|       |    //
   74|  8.51k|    fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
   75|  8.51k|}
_ZN11xercesc_3_210NameIdPoolINS_14DTDElementDeclEE9removeAllEv:
   91|  8.51k|{
   92|  8.51k|    if (fIdCounter == 0) return;
  ------------------
  |  Branch (92:9): [True: 8.51k, False: 0]
  ------------------
   93|       |
   94|      0|    fBucketList.removeAll();
   95|       |
   96|       |    // Reset the id counter
   97|      0|    fIdCounter = 0;
   98|      0|}
_ZN11xercesc_3_220NameIdPoolEnumeratorINS_14DTDElementDeclEE5ResetEv:
  269|  4.22k|{
  270|       |    //
  271|       |    //  Find the next available bucket element in the pool. We use the id
  272|       |    //  array since its very easy to enumerator through by just maintaining
  273|       |    //  an index. If the id counter is zero, then its empty and we leave the
  274|       |    //  current index to zero.
  275|       |    //
  276|  4.22k|    fCurIndex = fToEnum->fIdCounter ? 1:0;
  ------------------
  |  Branch (276:17): [True: 4.22k, False: 0]
  ------------------
  277|  4.22k|}
_ZNK11xercesc_3_220NameIdPoolEnumeratorINS_14DTDElementDeclEE15hasMoreElementsEv:
  250|  42.5k|{
  251|       |    // If our index is zero or past the end, then we are done
  252|  42.5k|    if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter))
  ------------------
  |  Branch (252:9): [True: 0, False: 42.5k]
  |  Branch (252:23): [True: 4.22k, False: 38.2k]
  ------------------
  253|  4.22k|        return false;
  254|  38.2k|    return true;
  255|  42.5k|}
_ZN11xercesc_3_220NameIdPoolEnumeratorINS_14DTDElementDeclEE11nextElementEv:
  258|  38.2k|{
  259|       |    // If our index is zero or past the end, then we are done
  260|  38.2k|    if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter))
  ------------------
  |  Branch (260:9): [True: 0, False: 38.2k]
  |  Branch (260:23): [True: 0, False: 38.2k]
  ------------------
  261|      0|        ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::Enum_NoMoreElements, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  262|       |
  263|       |    // Return the current element and bump the index
  264|  38.2k|    return *fToEnum->fIdPtrs[fCurIndex++];
  265|  38.2k|}
_ZN11xercesc_3_220NameIdPoolEnumeratorINS_13DTDEntityDeclEE5ResetEv:
  269|  4.22k|{
  270|       |    //
  271|       |    //  Find the next available bucket element in the pool. We use the id
  272|       |    //  array since its very easy to enumerator through by just maintaining
  273|       |    //  an index. If the id counter is zero, then its empty and we leave the
  274|       |    //  current index to zero.
  275|       |    //
  276|  4.22k|    fCurIndex = fToEnum->fIdCounter ? 1:0;
  ------------------
  |  Branch (276:17): [True: 1.20k, False: 3.01k]
  ------------------
  277|  4.22k|}
_ZNK11xercesc_3_220NameIdPoolEnumeratorINS_13DTDEntityDeclEE15hasMoreElementsEv:
  250|  5.69k|{
  251|       |    // If our index is zero or past the end, then we are done
  252|  5.69k|    if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter))
  ------------------
  |  Branch (252:9): [True: 3.01k, False: 2.67k]
  |  Branch (252:23): [True: 1.20k, False: 1.46k]
  ------------------
  253|  4.22k|        return false;
  254|  1.46k|    return true;
  255|  5.69k|}
_ZN11xercesc_3_220NameIdPoolEnumeratorINS_13DTDEntityDeclEE11nextElementEv:
  258|  1.46k|{
  259|       |    // If our index is zero or past the end, then we are done
  260|  1.46k|    if (!fCurIndex || (fCurIndex > fToEnum->fIdCounter))
  ------------------
  |  Branch (260:9): [True: 0, False: 1.46k]
  |  Branch (260:23): [True: 0, False: 1.46k]
  ------------------
  261|      0|        ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::Enum_NoMoreElements, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  262|       |
  263|       |    // Return the current element and bump the index
  264|  1.46k|    return *fToEnum->fIdPtrs[fCurIndex++];
  265|  1.46k|}
_ZN11xercesc_3_210NameIdPoolINS_13DTDEntityDeclEE8getByKeyEPKDs:
  107|  77.0k|{
  108|  77.0k|    if (fIdCounter == 0) return 0;
  ------------------
  |  Branch (108:9): [True: 4.59k, False: 72.4k]
  ------------------
  109|  72.4k|    return fBucketList.get(key);
  110|  77.0k|}
_ZN11xercesc_3_220NameIdPoolEnumeratorINS_14DTDElementDeclEEC2EPNS_10NameIdPoolIS1_EEPNS_13MemoryManagerE:
  211|  4.22k|{
  212|  4.22k|    Reset();
  213|  4.22k|}
_ZN11xercesc_3_220NameIdPoolEnumeratorINS_13DTDEntityDeclEEC2EPNS_10NameIdPoolIS1_EEPNS_13MemoryManagerE:
  211|  4.22k|{
  212|  4.22k|    Reset();
  213|  4.22k|}

_ZN11xercesc_3_224BinHTTPInputStreamCommonC2EPNS_13MemoryManagerE:
   52|    139|{
   53|    139|}
_ZN11xercesc_3_224BinHTTPInputStreamCommonD2Ev:
   57|    139|{
   58|    139|    if(fContentType) fMemoryManager->deallocate(fContentType);
  ------------------
  |  Branch (58:8): [True: 0, False: 139]
  ------------------
   59|    139|    if(fEncoding) fMemoryManager->deallocate(fEncoding);
  ------------------
  |  Branch (59:8): [True: 0, False: 139]
  ------------------
   60|    139|}

_ZN11xercesc_3_210CharBufferC2EmPNS_13MemoryManagerE:
   44|    228|    {
   45|    228|        fBuffer = (char*)fMemoryManager->allocate((fCapacity + 1) * sizeof(char));
   46|    228|    }
_ZN11xercesc_3_210CharBufferD2Ev:
   49|    228|    {
   50|    228|        fMemoryManager->deallocate(fBuffer);
   51|    228|    }
_ZN11xercesc_3_210CharBuffer12getRawBufferEv:
   60|    173|    {
   61|    173|        fBuffer[fIndex] = 0;
   62|    173|        return fBuffer;
   63|    173|    }
_ZN11xercesc_3_210CharBuffer19appendDecimalNumberEj:
  102|    674|    {
  103|    674|        if(n >= 10) {
  ------------------
  |  Branch (103:12): [True: 585, False: 89]
  ------------------
  104|    585|		appendDecimalNumber(n / 10);
  105|    585|		n = n % 10;
  106|    585|	}
  107|       |
  108|    674|        if(fIndex + 1 >= fCapacity)
  ------------------
  |  Branch (108:12): [True: 62, False: 612]
  ------------------
  109|     62|            ensureCapacity(1);
  110|       |
  111|    674|        fBuffer[fIndex] = '0' + n;
  112|    674|        ++fIndex;
  113|    674|    }
_ZN11xercesc_3_210CharBuffer14ensureCapacityEm:
  129|     62|    {
  130|       |        // If we can't handle it, try doubling the buffer size.
  131|     62|        XMLSize_t newCap = (fIndex + extraNeeded) * 2;
  132|       |
  133|     62|        if(newCap > fCapacity)
  ------------------
  |  Branch (133:12): [True: 62, False: 0]
  ------------------
  134|     62|        {
  135|       |            // Allocate new buffer
  136|     62|            char* newBuf = (char*)fMemoryManager->allocate((newCap + 1) * sizeof(char));
  137|       |
  138|       |            // Copy over the old stuff
  139|     62|            memcpy(newBuf, fBuffer, fIndex * sizeof(char));
  140|       |
  141|       |            // Clean up old buffer and store new stuff
  142|     62|            fMemoryManager->deallocate(fBuffer);
  143|     62|            fBuffer = newBuf;
  144|     62|            fCapacity = newCap;
  145|     62|        }
  146|     62|    }

_ZN11xercesc_3_217SocketNetAccessorC2Ev:
   40|      1|{
   41|       |    // Do any one time initialization here.
   42|       |    // Nothing to do, in this case.
   43|      1|}
_ZN11xercesc_3_217SocketNetAccessor7makeNewERKNS_6XMLURLEPKNS_14XMLNetHTTPInfoE:
   53|    150|{
   54|    150|    XMLURL::Protocols  protocol = urlSource.getProtocol();
   55|    150|    switch(protocol)
   56|    150|    {
   57|    139|        case XMLURL::HTTP:
  ------------------
  |  Branch (57:9): [True: 139, False: 11]
  ------------------
   58|    139|        {
   59|    139|            UnixHTTPURLInputStream* retStrm =
   60|    139|                new (urlSource.getMemoryManager()) UnixHTTPURLInputStream(urlSource, httpInfo);
   61|    139|            return retStrm;            
   62|      0|        }
   63|       |
   64|       |        //
   65|       |        // These are the only protocols we support now. So throw and
   66|       |        // unsupported protocol exception for the others.
   67|       |        //
   68|     11|        default :
  ------------------
  |  Branch (68:9): [True: 11, False: 139]
  ------------------
   69|     11|            ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_UnsupportedProto, urlSource.getMemoryManager());
  ------------------
  |  |  264|     11|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   70|      0|            break;
   71|    150|    }
   72|      0|    return 0;
   73|    150|}

_ZN11xercesc_3_222UnixHTTPURLInputStreamC2ERKNS_6XMLURLEPKNS_14XMLNetHTTPInfoE:
   98|    139|{
   99|       |    //
  100|       |    //  Convert the hostName to the platform's code page for gethostbyname and
  101|       |    //  inet_addr functions.
  102|       |    //
  103|       |
  104|    139|    MemoryManager *memoryManager = urlSource.getMemoryManager();
  105|       |
  106|    139|    const XMLCh*        hostName = urlSource.getHost();
  107|       |
  108|    139|    if (hostName == 0)
  ------------------
  |  Branch (108:9): [True: 4, False: 135]
  ------------------
  109|      4|      ThrowXMLwithMemMgr1(NetAccessorException,
  ------------------
  |  |  266|      4|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  110|    139|                          XMLExcepts::File_CouldNotOpenFile,
  111|    139|                          urlSource.getURLText(),
  112|    139|                          memoryManager);
  113|       |
  114|    135|    char*               hostNameAsCharStar = XMLString::transcode(hostName, memoryManager);
  115|    135|    ArrayJanitor<char>  janHostNameAsCharStar(hostNameAsCharStar, memoryManager);
  116|       |
  117|    135|    XMLURL url(urlSource);
  118|    135|    int redirectCount = 0;
  119|    135|    SocketJanitor janSock(0);
  120|       |
  121|    135|    do {
  122|       |        //
  123|       |        // Set up a socket.
  124|       |        //
  125|       |
  126|    135|#if HAVE_GETADDRINFO
  127|    135|        struct addrinfo hints, *res, *ai;
  128|       |
  129|    135|        CharBuffer portBuffer(10, memoryManager);
  130|    135|        portBuffer.appendDecimalNumber(url.getPortNum());
  131|       |
  132|    135|        memset(&hints, 0, sizeof(struct addrinfo));
  133|    135|        hints.ai_family = PF_UNSPEC;
  134|    135|        hints.ai_socktype = SOCK_STREAM;
  135|    135|        int n = getaddrinfo(hostNameAsCharStar,portBuffer.getRawBuffer(),&hints, &res);
  136|    135|        if(n != 0)
  ------------------
  |  Branch (136:12): [True: 84, False: 51]
  ------------------
  137|     84|        {
  138|     84|            hints.ai_flags = AI_NUMERICHOST;
  139|     84|            n = getaddrinfo(hostNameAsCharStar,portBuffer.getRawBuffer(),&hints, &res);
  140|     84|            if(n != 0)
  ------------------
  |  Branch (140:16): [True: 84, False: 0]
  ------------------
  141|     84|                ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::NetAcc_TargetResolution, hostName, memoryManager);
  ------------------
  |  |  266|     84|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  142|     84|        }
  143|     51|        janSock.reset();
  144|     51|        for (ai = res; ai != NULL; ai = ai->ai_next) {
  ------------------
  |  Branch (144:24): [True: 5, False: 46]
  ------------------
  145|       |            // Open a socket with the correct address family for this address.
  146|      5|            fSocket = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
  147|      5|            if (fSocket < 0)
  ------------------
  |  Branch (147:17): [True: 0, False: 5]
  ------------------
  148|      0|                continue;
  149|      5|            janSock.reset(&fSocket);
  150|      5|            if (connect(fSocket, ai->ai_addr, ai->ai_addrlen) < 0)
  ------------------
  |  Branch (150:17): [True: 5, False: 0]
  ------------------
  151|      5|            {
  152|      5|                freeaddrinfo(res);
  153|      5|                ThrowXMLwithMemMgr1(NetAccessorException,
  ------------------
  |  |  266|      5|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  154|      5|                         XMLExcepts::NetAcc_ConnSocket, url.getURLText(), memoryManager);
  155|      5|            }
  156|      0|            break;
  157|      5|        }
  158|     46|        freeaddrinfo(res);
  159|     46|        if (fSocket < 0)
  ------------------
  |  Branch (159:13): [True: 0, False: 46]
  ------------------
  160|      0|        {
  161|      0|            ThrowXMLwithMemMgr1(NetAccessorException,
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  162|      0|                     XMLExcepts::NetAcc_CreateSocket, url.getURLText(), memoryManager);
  163|      0|        }
  164|       |#else
  165|       |        struct hostent *hostEntPtr = 0;
  166|       |        struct sockaddr_in sa;
  167|       |
  168|       |        // Use the hostName in the local code page ....
  169|       |        if((hostEntPtr = gethostbyname(hostNameAsCharStar)) == NULL)
  170|       |        {
  171|       |            unsigned long  numAddress = inet_addr(hostNameAsCharStar);
  172|       |            if ((hostEntPtr =
  173|       |                    gethostbyaddr((char *) &numAddress,
  174|       |                        sizeof(unsigned long), AF_INET)) == NULL)
  175|       |            {
  176|       |                ThrowXMLwithMemMgr1(NetAccessorException,
  177|       |                    XMLExcepts::NetAcc_TargetResolution, hostName, memoryManager);
  178|       |            }
  179|       |        }
  180|       |
  181|       |        memset(&sa, '\0', sizeof(sockaddr_in));  // iSeries fix ??
  182|       |        memcpy((void *) &sa.sin_addr,
  183|       |            (const void *) hostEntPtr->h_addr, hostEntPtr->h_length);
  184|       |        sa.sin_family = hostEntPtr->h_addrtype;
  185|       |        sa.sin_port = htons((unsigned short)url.getPortNum());
  186|       |
  187|       |        janSock.reset();
  188|       |        fSocket = socket(hostEntPtr->h_addrtype, SOCK_STREAM, 0);
  189|       |        if(fSocket < 0)
  190|       |        {
  191|       |            ThrowXMLwithMemMgr1(NetAccessorException,
  192|       |                XMLExcepts::NetAcc_CreateSocket, url.getURLText(), memoryManager);
  193|       |        }
  194|       |        janSock.reset(&fSocket);
  195|       |
  196|       |        if(connect(fSocket, (struct sockaddr *) &sa, sizeof(sa)) < 0)
  197|       |        {
  198|       |            ThrowXMLwithMemMgr1(NetAccessorException,
  199|       |                XMLExcepts::NetAcc_ConnSocket, url.getURLText(), memoryManager);
  200|       |        }
  201|       |#endif
  202|       |
  203|     46|        int status = sendRequest(url, httpInfo);
  204|       |
  205|     46|        if(status == 200) {
  ------------------
  |  Branch (205:12): [True: 0, False: 46]
  ------------------
  206|       |            // HTTP 200 OK response means we're done.
  207|      0|            break;
  208|      0|        }
  209|       |        // a 3xx response means there was an HTTP redirect
  210|     46|        else if(status >= 300 && status <= 307) {
  ------------------
  |  Branch (210:17): [True: 0, False: 46]
  |  Branch (210:34): [True: 0, False: 0]
  ------------------
  211|      0|            redirectCount++;
  212|       |
  213|      0|            XMLCh *newURLString = findHeader("Location");
  214|      0|            ArrayJanitor<XMLCh> janNewURLString(newURLString, memoryManager);
  215|       |
  216|      0|            if(newURLString == 0 || *newURLString == 0) {
  ------------------
  |  Branch (216:16): [True: 0, False: 0]
  |  Branch (216:37): [True: 0, False: 0]
  ------------------
  217|      0|                ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, url.getURLText(), memoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  218|      0|            }
  219|       |
  220|      0|            XMLURL newURL(memoryManager);
  221|      0|            newURL.setURL(url, newURLString);
  222|      0|            if(newURL.getProtocol() != XMLURL::HTTP) {
  ------------------
  |  Branch (222:16): [True: 0, False: 0]
  ------------------
  223|      0|                ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, newURL.getURLText(), memoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  224|      0|            }
  225|       |
  226|      0|            url = newURL;
  227|      0|            hostName = newURL.getHost();
  228|       |
  229|      0|            if (hostName == 0)
  ------------------
  |  Branch (229:17): [True: 0, False: 0]
  ------------------
  230|      0|              ThrowXMLwithMemMgr1(NetAccessorException,
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  231|      0|                                  XMLExcepts::File_CouldNotOpenFile,
  232|      0|                                  newURL.getURLText(),
  233|      0|                                  memoryManager);
  234|       |
  235|      0|            janHostNameAsCharStar.release();
  236|      0|            hostNameAsCharStar = XMLString::transcode(hostName, memoryManager);
  237|      0|            janHostNameAsCharStar.reset(hostNameAsCharStar, memoryManager);
  238|      0|        }
  239|     46|        else {
  240|       |            // Most likely a 404 Not Found error.
  241|     46|            ThrowXMLwithMemMgr1(NetAccessorException, XMLExcepts::File_CouldNotOpenFile, url.getURLText(), memoryManager);
  ------------------
  |  |  266|     46|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  242|     46|        }
  243|     46|    } while(redirectCount < 6);
  ------------------
  |  Branch (243:13): [True: 0, False: 0]
  ------------------
  244|       |
  245|      0|    janSock.release();
  246|      0|}
_ZN11xercesc_3_213SocketJanitorC2EPi:
   61|     89|    SocketJanitor(int* toDelete) : fData(toDelete) {}
_ZN11xercesc_3_213SocketJanitor5resetEPi:
   68|     99|    {
   69|     99|        if(fData) {
  ------------------
  |  Branch (69:12): [True: 5, False: 94]
  ------------------
   70|      5|            shutdown(*fData, 2);
   71|      5|            close(*fData);
   72|      5|        }
   73|     99|        fData = p;
   74|     99|    }
_ZN11xercesc_3_213SocketJanitorD2Ev:
   62|     89|    ~SocketJanitor() { reset(); }

_ZN11xercesc_3_212PanicHandlerC2Ev:
   70|      1|    PanicHandler(){};

_ZN11xercesc_3_216XMLPlatformUtils10InitializeEPKcS2_PNS_12PanicHandlerEPNS_13MemoryManagerE:
  166|      1|{
  167|       |    //
  168|       |    //  Effects of overflow:
  169|       |    //  . resouce re-allocations
  170|       |    //  . consequently resource leaks
  171|       |    //  . potentially terminate() may never get executed
  172|       |    //
  173|       |    //  We got to prevent overflow from happening.
  174|       |    //  no error or exception
  175|       |    //
  176|      1|    if (gInitFlag == LONG_MAX)
  ------------------
  |  Branch (176:9): [True: 0, False: 1]
  ------------------
  177|      0|        return;
  178|       |
  179|       |    //
  180|       |    //  Make sure we haven't already been initialized. Note that this is not
  181|       |    //  thread safe and is not intended for that. Its more for those COM
  182|       |    //  like processes that cannot keep up with whether they have initialized
  183|       |    //  us yet or not.
  184|       |    //
  185|      1|    gInitFlag++;
  186|       |
  187|      1|    if (gInitFlag > 1)
  ------------------
  |  Branch (187:9): [True: 0, False: 1]
  ------------------
  188|      0|      return;
  189|       |
  190|       |    // Set pluggable memory manager
  191|      1|    if (!fgMemoryManager)
  ------------------
  |  Branch (191:9): [True: 1, False: 0]
  ------------------
  192|      1|    {
  193|      1|        if (memoryManager)
  ------------------
  |  Branch (193:13): [True: 0, False: 1]
  ------------------
  194|      0|        {
  195|      0|            fgMemoryManager = memoryManager;
  196|      0|            fgMemMgrAdopted = false;
  197|      0|        }
  198|      1|        else
  199|      1|        {
  200|      1|            fgMemoryManager = new MemoryManagerImpl();
  201|      1|        }
  202|      1|    }
  203|       |
  204|       |    /***
  205|       |     * Panic Handler:
  206|       |     *
  207|       |     ***/
  208|      1|    if (!panicHandler)
  ------------------
  |  Branch (208:9): [True: 1, False: 0]
  ------------------
  209|      1|    {
  210|      1|        fgDefaultPanicHandler = new DefaultPanicHandler();
  211|      1|    }
  212|      0|    else
  213|      0|    {
  214|      0|        fgUserPanicHandler = panicHandler;
  215|      0|    }
  216|       |
  217|       |
  218|       |    // Determine our endianness (with regard to a XMLCh 16-bit word)
  219|      1|    union {
  220|      1|    	XMLCh ch;
  221|      1|    	unsigned char ar[sizeof(XMLCh)];
  222|      1|    } endianTest;
  223|      1|    endianTest.ch = 1;
  224|      1|    fgXMLChBigEndian = (endianTest.ar[sizeof(XMLCh)-1] == 1);
  225|       |
  226|       |    // Determine if we can use SSE2 functions
  227|       |#if defined(XERCES_HAVE_CPUID_INTRINSIC)
  228|       |    int CPUInfo[4]={0};
  229|       |    __cpuid(CPUInfo, 1);
  230|       |    if(CPUInfo[3] & (1UL << 26))
  231|       |        fgSSE2ok = true;
  232|       |    else
  233|       |        fgSSE2ok = false;
  234|       |#elif defined(XERCES_HAVE_GETCPUID)
  235|      1|    unsigned int eax, ebx, ecx, edx;
  236|      1|    if(!__get_cpuid (1, &eax, &ebx, &ecx, &edx) || (edx & (1UL << 26))==0)
  ------------------
  |  Branch (236:8): [True: 0, False: 1]
  |  Branch (236:52): [True: 0, False: 1]
  ------------------
  237|      0|        fgSSE2ok = false;
  238|      1|    else
  239|      1|        fgSSE2ok = true;
  240|       |#elif defined(XERCES_HAVE_SSE2_INTRINSIC)
  241|       |    // if we cannot find out at runtime, assume the define has it right
  242|       |    fgSSE2ok = true;
  243|       |#else
  244|       |    fgSSE2ok = false;
  245|       |#endif
  246|       |
  247|       |    // Initialize the platform-specific mutex and file mgrs
  248|      1|    fgMutexMgr		= makeMutexMgr(fgMemoryManager);
  249|      1|    fgFileMgr		= makeFileMgr(fgMemoryManager);
  250|       |
  251|       |
  252|       |    // Create the local sync mutex
  253|      1|    gSyncMutex = new XMLMutex(fgMemoryManager);
  254|       |
  255|       |    // Create the global "atomic operations" mutex.
  256|      1|    fgAtomicMutex = new XMLMutex(fgMemoryManager);
  257|       |
  258|       |    //
  259|       |    //  Ask the per-platform code to make the desired transcoding service for
  260|       |    //  us to use. This call cannot throw any exceptions or do anything that
  261|       |    //  cause any transcoding to happen. It should create the service and
  262|       |    //  return it or zero if it cannot.
  263|       |    //
  264|       |    //  This one also cannot use any utility services. It can only create a
  265|       |    //  transcoding service object and return it.
  266|       |    //
  267|       |    //  If we cannot make one, then we call panic to end the process.
  268|       |    //
  269|      1|    XMLInitializer::initializeTransService(); // TransService static data.
  270|       |
  271|      1|    fgTransService = makeTransService();
  272|       |
  273|      1|    if (!fgTransService)
  ------------------
  |  Branch (273:9): [True: 0, False: 1]
  ------------------
  274|      0|        panic(PanicHandler::Panic_NoTransService);
  275|       |
  276|       |    // Initialize the transcoder service
  277|      1|    fgTransService->initTransService();
  278|       |
  279|       |    //
  280|       |    //  Try to create a default local code page transcoder. This is the one
  281|       |    //  that will be used internally by the XMLString class. If we cannot
  282|       |    //  create one, then call the panic method.
  283|       |    //
  284|      1|    XMLLCPTranscoder* defXCode = XMLPlatformUtils::fgTransService->makeNewLCPTranscoder(fgMemoryManager);
  285|      1|    if (!defXCode)
  ------------------
  |  Branch (285:9): [True: 0, False: 1]
  ------------------
  286|      0|        panic(PanicHandler::Panic_NoDefTranscoder);
  287|      1|    XMLString::initString(defXCode, fgMemoryManager);
  288|       |
  289|       |    //
  290|       |    //  Now lets ask the per-platform code to give us an instance of the type
  291|       |    //  of network access implementation he wants to use. This can return
  292|       |    //  a zero pointer if this platform doesn't want to support this.
  293|       |    //
  294|      1|    fgNetAccessor = makeNetAccessor();
  295|       |
  296|       |    /***
  297|       |     * Message Loader:
  298|       |     *
  299|       |     *     Locale setting
  300|       |     *     nlsHome setting
  301|       |     ***/
  302|      1|    XMLMsgLoader::setLocale(locale);
  303|      1|    XMLMsgLoader::setNLSHome(nlsHome);
  304|       |
  305|       |    // Initialize static data.
  306|       |    //
  307|      1|    XMLInitializer::initializeStaticData();
  308|      1|}
_ZN11xercesc_3_216XMLPlatformUtils15makeNetAccessorEv:
  416|      1|{
  417|      1|	XMLNetAccessor* na = 0;
  418|       |
  419|       |#if defined (XERCES_USE_NETACCESSOR_CURL)
  420|       |		na = new CurlNetAccessor();
  421|       |#elif defined (XERCES_USE_NETACCESSOR_SOCKET)
  422|      1|		na = new SocketNetAccessor();
  423|       |#elif defined (XERCES_USE_NETACCESSOR_CFURL)
  424|       |		na = new MacOSURLAccessCF();
  425|       |#elif defined (XERCES_USE_NETACCESSOR_WINSOCK)
  426|       |		na = new WinSockNetAccessor();
  427|       |#endif
  428|       |
  429|      1|	return na;
  430|      1|}
_ZN11xercesc_3_216XMLPlatformUtils11loadAMsgSetEPKDs:
  439|      8|{
  440|      8|    XMLMsgLoader* ms=0;
  441|       |
  442|      8|    try
  443|      8|    {
  444|       |	#if defined (XERCES_USE_MSGLOADER_ICU)
  445|       |		ms = new ICUMsgLoader(msgDomain);
  446|       |	#elif defined (XERCES_USE_MSGLOADER_ICONV)
  447|       |		ms = new MsgCatalogLoader(msgDomain);
  448|       |	#elif defined (XERCES_USE_MSGLOADER_INMEMORY)
  449|      8|		ms = new InMemMsgLoader(msgDomain);
  450|       |	#else
  451|       |		#error No MsgLoader configured for platform! You must configure it.
  452|       |	#endif
  453|      8|    }
  454|      8|    catch(const OutOfMemoryException&)
  455|      8|    {
  456|      0|        throw;
  457|      0|    }
  458|      8|    catch(...)
  459|      8|    {
  460|      0|        panic(PanicHandler::Panic_CantLoadMsgDomain);
  461|      0|    }
  462|       |
  463|      8|    return ms;
  464|      8|}
_ZN11xercesc_3_216XMLPlatformUtils16makeTransServiceEv:
  475|      1|{
  476|      1|	XMLTransService* tc = 0;
  477|       |
  478|       |	#if defined   (XERCES_USE_TRANSCODER_ICU)
  479|       |		tc = new ICUTransService(fgMemoryManager);
  480|       |	#elif defined (XERCES_USE_TRANSCODER_GNUICONV)
  481|      1|		tc = new IconvGNUTransService(fgMemoryManager);
  482|       |	#elif defined (XERCES_USE_TRANSCODER_ICONV)
  483|       |		tc = new IconvTransService(fgMemoryManager);
  484|       |	#elif defined (XERCES_USE_TRANSCODER_MACOSUNICODECONVERTER)
  485|       |		tc = new MacOSUnicodeConverter(fgMemoryManager);
  486|       |	#elif defined (XERCES_USE_TRANSCODER_WINDOWS)
  487|       |		tc = new Win32TransService(fgMemoryManager);
  488|       |	#else
  489|       |		#error No Transcoder configured for platform! You must configure it.
  490|       |	#endif
  491|       |
  492|      1|	return tc;
  493|      1|}
_ZN11xercesc_3_216XMLPlatformUtils11makeFileMgrEPNS_13MemoryManagerE:
  501|      1|{
  502|      1|	XMLFileMgr* mgr = NULL;
  503|       |
  504|      1|	#if XERCES_USE_FILEMGR_POSIX
  505|      1|		mgr = new (memmgr) PosixFileMgr;
  506|       |	#elif XERCES_USE_FILEMGR_WINDOWS
  507|       |		mgr = new (memmgr) WindowsFileMgr;
  508|       |	#else
  509|       |		#error No File Manager configured for platform! You must configure it.
  510|       |	#endif
  511|       |
  512|      1|	return mgr;
  513|      1|}
_ZN11xercesc_3_216XMLPlatformUtils8openFileEPKDsPNS_13MemoryManagerE:
  529|  2.23k|{
  530|  2.23k|    if (!fgFileMgr)
  ------------------
  |  Branch (530:9): [True: 0, False: 2.23k]
  ------------------
  531|      0|		ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::CPtr_PointerIsZero, memmgr);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  532|       |
  533|  2.23k|	return fgFileMgr->fileOpen(fileName, false, memmgr);
  534|  2.23k|}
_ZN11xercesc_3_216XMLPlatformUtils9closeFileEPvPNS_13MemoryManagerE:
  572|     10|{
  573|     10|    if (!fgFileMgr)
  ------------------
  |  Branch (573:9): [True: 0, False: 10]
  ------------------
  574|      0|		ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::CPtr_PointerIsZero, memmgr);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  575|       |
  576|     10|	fgFileMgr->fileClose(theFile, memmgr);
  577|     10|}
_ZN11xercesc_3_216XMLPlatformUtils14readFileBufferEPvmPhPNS_13MemoryManagerE:
  616|     10|{
  617|     10|    if (!fgFileMgr)
  ------------------
  |  Branch (617:9): [True: 0, False: 10]
  ------------------
  618|      0|		ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::CPtr_PointerIsZero, memmgr);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  619|       |
  620|     10|    return fgFileMgr->fileRead(theFile, toRead, toFill, memmgr);
  621|     10|}
_ZN11xercesc_3_216XMLPlatformUtils10isRelativeEPKDsPNS_13MemoryManagerE:
  661|  2.23k|{
  662|  2.23k|    if (!fgFileMgr)
  ------------------
  |  Branch (662:9): [True: 0, False: 2.23k]
  ------------------
  663|      0|		ThrowXMLwithMemMgr(XMLPlatformUtilsException, XMLExcepts::CPtr_PointerIsZero, memmgr);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  664|       |
  665|  2.23k|    return fgFileMgr->isRelative(toCheck, memmgr);
  666|  2.23k|}
_ZN11xercesc_3_216XMLPlatformUtils12makeMutexMgrEPNS_13MemoryManagerE:
  722|      1|{
  723|      1|	XMLMutexMgr* mgr = NULL;
  724|       |
  725|       |	#if XERCES_USE_MUTEXMGR_NOTHREAD
  726|       |		mgr = new (memmgr) NoThreadMutexMgr;
  727|       |	#elif XERCES_USE_MUTEXMGR_STD
  728|      1|		mgr = new (memmgr) StdMutexMgr;
  729|       |	#elif XERCES_USE_MUTEXMGR_POSIX
  730|       |		mgr = new (memmgr) PosixMutexMgr;
  731|       |	#elif XERCES_USE_MUTEXMGR_WINDOWS
  732|       |		mgr = new (memmgr) WindowsMutexMgr;
  733|       |	#else
  734|       |		#error No Mutex Manager configured for platform! You must configure it.
  735|       |	#endif
  736|       |
  737|      1|	return mgr;
  738|      1|}
_ZN11xercesc_3_216XMLPlatformUtils9makeMutexEPNS_13MemoryManagerE:
  742|  7.26k|{
  743|  7.26k|    if (!fgMutexMgr)
  ------------------
  |  Branch (743:9): [True: 0, False: 7.26k]
  ------------------
  744|      0|		XMLPlatformUtils::panic(PanicHandler::Panic_MutexErr);
  745|       |
  746|  7.26k|	return fgMutexMgr->create(memmgr);
  747|  7.26k|}
_ZN11xercesc_3_216XMLPlatformUtils10closeMutexEPvPNS_13MemoryManagerE:
  751|  7.25k|{
  752|  7.25k|    if (!fgMutexMgr)
  ------------------
  |  Branch (752:9): [True: 0, False: 7.25k]
  ------------------
  753|      0|		XMLPlatformUtils::panic(PanicHandler::Panic_MutexErr);
  754|       |
  755|  7.25k|	fgMutexMgr->destroy(mtx, memmgr);
  756|  7.25k|}
_ZN11xercesc_3_216XMLPlatformUtils9lockMutexEPv:
  760|  58.8k|{
  761|  58.8k|    if (!fgMutexMgr)
  ------------------
  |  Branch (761:9): [True: 0, False: 58.8k]
  ------------------
  762|      0|		XMLPlatformUtils::panic(PanicHandler::Panic_MutexErr);
  763|       |
  764|  58.8k|	fgMutexMgr->lock(mtx);
  765|  58.8k|}
_ZN11xercesc_3_216XMLPlatformUtils11unlockMutexEPv:
  769|  58.8k|{
  770|  58.8k|    if (!fgMutexMgr)
  ------------------
  |  Branch (770:9): [True: 0, False: 58.8k]
  ------------------
  771|      0|		XMLPlatformUtils::panic(PanicHandler::Panic_MutexErr);
  772|       |
  773|  58.8k|	fgMutexMgr->unlock(mtx);
  774|  58.8k|}
_ZN11xercesc_3_216XMLPlatformUtils10loadMsgSetEPKDs:
  780|      8|{
  781|       |    //
  782|       |    //  Ask the platform support to load up the correct type of message
  783|       |    //  loader for the indicated message set. We don't check here whether it
  784|       |    //  works or not. That's their decision.
  785|       |    //
  786|      8|    return loadAMsgSet(msgDomain);
  787|      8|}
_ZN11xercesc_3_216XMLPlatformUtils10weavePathsEPKDsS2_PNS_13MemoryManagerE:
  881|  2.15k|{
  882|       |    // Create a buffer as large as both parts and empty it
  883|  2.15k|    XMLCh* tmpBuf = (XMLCh*) manager->allocate
  884|  2.15k|    (
  885|  2.15k|        (XMLString::stringLen(basePath)
  886|  2.15k|         + XMLString::stringLen(relativePath) + 2) * sizeof(XMLCh)
  887|  2.15k|    );//new XMLCh[XMLString::stringLen(basePath) + XMLString::stringLen(relativePath) + 2];
  888|  2.15k|    *tmpBuf = 0;
  889|       |
  890|       |    //
  891|       |    //  If we have no base path, then just take the relative path as is.
  892|       |    //
  893|  2.15k|    if ((!basePath) || (!*basePath))
  ------------------
  |  Branch (893:9): [True: 0, False: 2.15k]
  |  Branch (893:24): [True: 0, False: 2.15k]
  ------------------
  894|      0|    {
  895|      0|        XMLString::copyString(tmpBuf, relativePath);
  896|      0|        return tmpBuf;
  897|      0|    }
  898|       |
  899|       |    //
  900|       |    // Remove anything after the last slash
  901|       |    //
  902|  2.15k|    const XMLCh* basePtr = basePath + (XMLString::stringLen(basePath) - 1);
  903|  19.3k|    while ((basePtr >= basePath)  &&  ((isAnySlash(*basePtr) == false)))
  ------------------
  |  Branch (903:12): [True: 17.2k, False: 2.15k]
  |  Branch (903:39): [True: 17.2k, False: 0]
  ------------------
  904|  17.2k|    {
  905|  17.2k|        basePtr--;
  906|  17.2k|    }
  907|       |
  908|       |    // There is no relevant base path, so just take the relative part
  909|  2.15k|    if (basePtr < basePath)
  ------------------
  |  Branch (909:9): [True: 2.15k, False: 0]
  ------------------
  910|  2.15k|    {
  911|  2.15k|        XMLString::copyString(tmpBuf, relativePath);
  912|  2.15k|        return tmpBuf;
  913|  2.15k|    }
  914|       |
  915|       |    //
  916|       |    // 1. concatenate the base and relative
  917|       |    // 2. remove all occurences of "/./"
  918|       |    // 3. remove all occurences of segment/../ where segment is not ../
  919|       |	//
  920|       |
  921|      0|    XMLString::subString(tmpBuf, basePath, 0, (basePtr - basePath + 1), manager);
  922|      0|    tmpBuf[basePtr - basePath + 1] = 0;
  923|      0|    if (relativePath)
  ------------------
  |  Branch (923:9): [True: 0, False: 0]
  ------------------
  924|      0|    {
  925|      0|        XMLString::catString(tmpBuf, relativePath);
  926|      0|    }
  927|       |
  928|      0|    removeDotSlash(tmpBuf, manager);
  929|       |
  930|      0|    removeDotDotSlash(tmpBuf, manager);
  931|       |
  932|      0|    return tmpBuf;
  933|       |
  934|  2.15k|}
_ZN11xercesc_3_216XMLPlatformUtils14removeDotSlashEPDsPNS_13MemoryManagerE:
  945|     84|{
  946|     84|    if ((!path) || (!*path))
  ------------------
  |  Branch (946:9): [True: 0, False: 84]
  |  Branch (946:20): [True: 1, False: 83]
  ------------------
  947|      1|        return;
  948|       |
  949|     83|    XMLCh* srcPtr = XMLString::replicate(path, manager);
  950|     83|    XMLSize_t srcLen = XMLString::stringLen(srcPtr);
  951|     83|    ArrayJanitor<XMLCh>   janName(srcPtr, manager);
  952|     83|    XMLCh* tarPtr = path;
  953|       |
  954|   322k|    while (*srcPtr)
  ------------------
  |  Branch (954:12): [True: 322k, False: 83]
  ------------------
  955|   322k|    {
  956|   322k|        if ( 3 <= srcLen )
  ------------------
  |  Branch (956:14): [True: 322k, False: 83]
  ------------------
  957|   322k|        {
  958|   322k|            if ( (isAnySlash(*srcPtr))     &&
  ------------------
  |  Branch (958:18): [True: 39.1k, False: 283k]
  ------------------
  959|   322k|                (chPeriod == *(srcPtr+1)) &&
  ------------------
  |  Branch (959:17): [True: 7.38k, False: 31.7k]
  ------------------
  960|   322k|                (isAnySlash(*(srcPtr+2)))  )
  ------------------
  |  Branch (960:17): [True: 272, False: 7.11k]
  ------------------
  961|    272|            {
  962|       |                // "\.\x" seen
  963|       |                // skip the first two, and start from the 3rd,
  964|       |                // since "\x" could be another "\."
  965|    272|                srcPtr+=2;
  966|    272|                srcLen-=2;
  967|    272|            }
  968|   322k|            else
  969|   322k|            {
  970|   322k|                *tarPtr++ = *srcPtr++;  // eat the current char
  971|   322k|                srcLen--;
  972|   322k|            }
  973|   322k|        }
  974|     83|        else if ( 1 == srcLen )
  ------------------
  |  Branch (974:19): [True: 14, False: 69]
  ------------------
  975|     14|        {
  976|     14|            *tarPtr++ = *srcPtr++;
  977|     14|        }
  978|     69|        else if ( 2 == srcLen)
  ------------------
  |  Branch (978:19): [True: 69, False: 0]
  ------------------
  979|     69|        {
  980|     69|            *tarPtr++ = *srcPtr++;
  981|     69|            *tarPtr++ = *srcPtr++;
  982|     69|        }
  983|       |
  984|   322k|    }
  985|       |
  986|     83|    *tarPtr = 0;
  987|       |
  988|     83|    return;
  989|     84|}
_ZN11xercesc_3_216XMLPlatformUtils10isAnySlashEDs:
  671|   347k|{
  672|       |	// As far as we know, all supported Xerces
  673|       |	// platforms use at least a forward slash
  674|       |	// as a path delimiter. So we always check for
  675|       |	// that.
  676|       |	//
  677|       |	// If XERCES_PATH_DELIMITER_BACKSLASH evaluates to true,
  678|       |	// we also consider that as a slash.
  679|       |	//
  680|       |	// XERCES_PATH_DELIMITER_BACKSLASH may be set in config.h
  681|       |	// by configure, or elsewhere by platform-specific
  682|       |	// code.
  683|   347k|    return	(
  684|   347k|			false
  ------------------
  |  Branch (684:4): [Folded - Ignored]
  ------------------
  685|   347k|		 || chForwardSlash == c
  ------------------
  |  Branch (685:7): [True: 39.4k, False: 307k]
  ------------------
  686|       |	#if XERCES_PATH_DELIMITER_BACKSLASH
  687|       |		 || chBackSlash == c
  688|       |	#endif
  689|   347k|     		);
  690|   347k|}

_ZN11xercesc_3_216XMLPlatformUtils33alignPointerForNewBlockAllocationEm:
  801|  52.7M|{
  802|       |    //    Macro XML_PLATFORM_NEW_BLOCK_ALIGNMENT may be defined
  803|       |    //    as needed to dictate alignment requirements on a
  804|       |    //    per-architecture basis. In the absense of that we
  805|       |    //    take an educated guess.
  806|       |#ifdef XML_PLATFORM_NEW_BLOCK_ALIGNMENT
  807|       |    const XMLSize_t alignment = XML_PLATFORM_NEW_BLOCK_ALIGNMENT;
  808|       |#else
  809|  52.7M|    const XMLSize_t alignment = (sizeof(void*) >= sizeof(double)) ? sizeof(void*) : sizeof(double);
  ------------------
  |  Branch (809:33): [Folded - Ignored]
  ------------------
  810|  52.7M|#endif
  811|       |
  812|       |    //    Calculate current alignment of pointer
  813|  52.7M|    XMLSize_t current = ptrSize % alignment;
  814|       |
  815|       |    //    Adjust pointer alignment as needed
  816|  52.7M|    return (current == 0)
  ------------------
  |  Branch (816:12): [True: 52.7M, False: 0]
  ------------------
  817|  52.7M|         ? ptrSize
  818|  52.7M|         : (ptrSize + alignment - current);
  819|  52.7M|}

_ZN11xercesc_3_25QNameC2EPNS_13MemoryManagerE:
   40|  1.32M|{
   41|  1.32M|}
_ZN11xercesc_3_25QNameC2EPKDsS2_jPNS_13MemoryManagerE:
   57|  5.36k|{
   58|  5.36k|    CleanupType cleanup(this, &QName::cleanUp);
   59|       |
   60|  5.36k|    try
   61|  5.36k|    {
   62|       |        //
   63|       |        //  Just call the local setters to set up everything. Too much
   64|       |        //  work is required to replicate that functionality here.
   65|       |        //
   66|  5.36k|        setName(prefix, localPart, uriId);
   67|  5.36k|    }
   68|  5.36k|    catch(const OutOfMemoryException&)
   69|  5.36k|    {
   70|      0|        cleanup.release();
   71|       |
   72|      0|        throw;
   73|      0|    }
   74|       |
   75|  5.36k|    cleanup.release();
   76|  5.36k|}
_ZN11xercesc_3_25QNameC2EPKDsjPNS_13MemoryManagerE:
   89|  52.7k|{
   90|  52.7k|    CleanupType cleanup(this, &QName::cleanUp);
   91|       |
   92|  52.7k|    try
   93|  52.7k|    {
   94|       |        //
   95|       |        //  Just call the local setters to set up everything. Too much
   96|       |        //  work is required to replicate that functionality here.
   97|       |        //
   98|  52.7k|        setName(rawName, uriId);
   99|  52.7k|    }
  100|  52.7k|    catch(const OutOfMemoryException&)
  101|  52.7k|    {
  102|      0|        cleanup.release();
  103|       |
  104|      0|        throw;
  105|      0|    }
  106|       |
  107|  52.7k|    cleanup.release();
  108|  52.7k|}
_ZN11xercesc_3_25QNameD2Ev:
  111|  2.93M|{
  112|  2.93M|	cleanUp();
  113|  2.93M|}
_ZN11xercesc_3_25QNameC2ERKS0_:
  129|  1.55M|{
  130|  1.55M|    XMLSize_t newLen;
  131|       |
  132|  1.55M|    newLen = XMLString::stringLen(qname.getLocalPart());
  133|  1.55M|    fLocalPartBufSz = newLen + 8;
  134|  1.55M|    fLocalPart = (XMLCh*) fMemoryManager->allocate
  135|  1.55M|    (
  136|  1.55M|        (fLocalPartBufSz + 1) * sizeof(XMLCh)
  137|  1.55M|    ); //new XMLCh[fLocalPartBufSz + 1];
  138|  1.55M|    XMLString::moveChars(fLocalPart, qname.getLocalPart(), newLen + 1);
  139|       |
  140|  1.55M|    newLen = XMLString::stringLen(qname.getPrefix());
  141|  1.55M|    fPrefixBufSz = newLen + 8;
  142|  1.55M|    fPrefix = (XMLCh*) fMemoryManager->allocate
  143|  1.55M|    (
  144|  1.55M|        (fPrefixBufSz + 1) * sizeof(XMLCh)
  145|  1.55M|    ); //new XMLCh[fPrefixBufSz + 1];
  146|  1.55M|    XMLString::moveChars(fPrefix, qname.getPrefix(), newLen + 1);
  147|       |
  148|  1.55M|    fURIId = qname.getURI();
  149|  1.55M|}
_ZNK11xercesc_3_25QName10getRawNameEv:
  155|   142M|{
  156|       |    //
  157|       |    //  If there is no buffer, or if there is but we've not faulted in the
  158|       |    //  value yet, then we have to do that now.
  159|       |    //
  160|   142M|    if (!fRawName || !*fRawName)
  ------------------
  |  Branch (160:9): [True: 141M, False: 880k]
  |  Branch (160:22): [True: 0, False: 880k]
  ------------------
  161|   141M|    {
  162|       |        //
  163|       |        //  If we have a prefix, then do the prefix:name version. Else, its
  164|       |        //  just the name.
  165|       |        //
  166|   141M|        if (*fPrefix)
  ------------------
  |  Branch (166:13): [True: 4.83k, False: 141M]
  ------------------
  167|  4.83k|        {
  168|       |            //
  169|       |            //  Calculate the worst case size buffer we will need. We use the
  170|       |            //  current high water marks of the prefix and name buffers, so it
  171|       |            //  might be a little wasteful of memory but we don't have to do
  172|       |            //  string len operations on the two strings.
  173|       |            //
  174|  4.83k|            const XMLSize_t neededLen = fPrefixBufSz + fLocalPartBufSz + 1;
  175|       |
  176|       |            //
  177|       |            //  If no buffer, or the current one is too small, then allocate one
  178|       |            //  and get rid of any old one.
  179|       |            //
  180|  4.83k|            if (!fRawName || (neededLen > fRawNameBufSz))
  ------------------
  |  Branch (180:17): [True: 4.83k, False: 0]
  |  Branch (180:30): [True: 0, False: 0]
  ------------------
  181|  4.83k|            {
  182|  4.83k|                fMemoryManager->deallocate(fRawName); //delete [] fRawName;
  183|       |
  184|  4.83k|                (const_cast<QName*>(this))->fRawName = 0;
  185|       |                // We have to cast off the const'ness to do this
  186|  4.83k|                (const_cast<QName*>(this))->fRawNameBufSz = neededLen;
  187|  4.83k|                (const_cast<QName*>(this))->fRawName = (XMLCh*) fMemoryManager->allocate
  188|  4.83k|                (
  189|  4.83k|                    (neededLen + 1) * sizeof(XMLCh)
  190|  4.83k|                ); //new XMLCh[neededLen + 1];
  191|       |
  192|       |                // Make sure its initially empty
  193|  4.83k|                *fRawName = 0;
  194|  4.83k|            }
  195|       |
  196|  4.83k|            const XMLSize_t prefixLen = XMLString::stringLen(fPrefix);
  197|       |
  198|  4.83k|            XMLString::moveChars(fRawName, fPrefix, prefixLen);
  199|  4.83k|            fRawName[prefixLen] = chColon;
  200|  4.83k|            XMLString::copyString(&fRawName[prefixLen+1], fLocalPart);
  201|  4.83k|        }
  202|   141M|         else
  203|   141M|        {
  204|   141M|            return fLocalPart;
  205|   141M|        }
  206|   141M|    }
  207|   885k|    return fRawName;
  208|   142M|}
_ZN11xercesc_3_25QName10getRawNameEv:
  211|  1.31M|{
  212|       |    //
  213|       |    //  If there is no buffer, or if there is but we've not faulted in the
  214|       |    //  value yet, then we have to do that now.
  215|       |    //
  216|  1.31M|    if (!fRawName || !*fRawName)
  ------------------
  |  Branch (216:9): [True: 1.08M, False: 227k]
  |  Branch (216:22): [True: 0, False: 227k]
  ------------------
  217|  1.08M|    {
  218|       |        //
  219|       |        //  If we have a prefix, then do the prefix:name version. Else, its
  220|       |        //  just the name.
  221|       |        //
  222|  1.08M|        if (*fPrefix)
  ------------------
  |  Branch (222:13): [True: 36, False: 1.08M]
  ------------------
  223|     36|        {
  224|       |            //
  225|       |            //  Calculate the worst case size buffer we will need. We use the
  226|       |            //  current high water marks of the prefix and name buffers, so it
  227|       |            //  might be a little wasteful of memory but we don't have to do
  228|       |            //  string len operations on the two strings.
  229|       |            //
  230|     36|            const XMLSize_t neededLen = fPrefixBufSz + fLocalPartBufSz + 1;
  231|       |
  232|       |            //
  233|       |            //  If no buffer, or the current one is too small, then allocate one
  234|       |            //  and get rid of any old one.
  235|       |            //
  236|     36|            if (!fRawName || (neededLen > fRawNameBufSz))
  ------------------
  |  Branch (236:17): [True: 36, False: 0]
  |  Branch (236:30): [True: 0, False: 0]
  ------------------
  237|     36|            {
  238|     36|                fMemoryManager->deallocate(fRawName); //delete [] fRawName;
  239|       |                
  240|     36|                fRawName = 0;
  241|       |                // We have to cast off the const'ness to do this
  242|     36|                (const_cast<QName*>(this))->fRawNameBufSz = neededLen;
  243|     36|                (const_cast<QName*>(this))->fRawName = (XMLCh*) fMemoryManager->allocate
  244|     36|                (
  245|     36|                    (neededLen + 1) * sizeof(XMLCh)
  246|     36|                ); //new XMLCh[neededLen + 1];
  247|       |
  248|       |                // Make sure its initially empty
  249|     36|                *fRawName = 0;
  250|     36|            }
  251|       |
  252|       |
  253|     36|            const XMLSize_t prefixLen = XMLString::stringLen(fPrefix);
  254|       |
  255|     36|            XMLString::moveChars(fRawName, fPrefix, prefixLen);
  256|     36|            fRawName[prefixLen] = chColon;
  257|     36|            XMLString::copyString(&fRawName[prefixLen+1], fLocalPart);
  258|     36|        }
  259|  1.08M|         else
  260|  1.08M|        {
  261|  1.08M|            return fLocalPart;
  262|  1.08M|        }
  263|  1.08M|    }
  264|   227k|    return fRawName;
  265|  1.31M|}
_ZN11xercesc_3_25QName7setNameEPKDsS2_j:
  273|   519k|{
  274|   519k|    setPrefix(prefix);
  275|   519k|    setLocalPart(localPart);
  276|       |
  277|       |    // And clean up any QName and leave it undone until/if asked for again
  278|   519k|    if (fRawName)
  ------------------
  |  Branch (278:9): [True: 0, False: 519k]
  ------------------
  279|      0|        *fRawName = 0;
  280|       |
  281|       |    // And finally store the URI id parameter
  282|   519k|    fURIId = uriId;
  283|   519k|}
_ZN11xercesc_3_25QName7setNameEPKDsj:
  287|  54.7k|{
  288|       |    //set the rawName
  289|  54.7k|    XMLSize_t newLen = XMLString::stringLen(rawName);
  290|       |    //find out the prefix and localPart from the rawName
  291|  54.7k|    const int colonInd = XMLString::indexOf(rawName, chColon);
  292|       |
  293|  54.7k|    if (colonInd >= 0)
  ------------------
  |  Branch (293:9): [True: 5.05k, False: 49.6k]
  ------------------
  294|  5.05k|    {
  295|  5.05k|        if (!fRawNameBufSz || (newLen > fRawNameBufSz))
  ------------------
  |  Branch (295:13): [True: 4.73k, False: 324]
  |  Branch (295:31): [True: 11, False: 313]
  ------------------
  296|  4.74k|        {
  297|  4.74k|            fMemoryManager->deallocate(fRawName); //delete [] fRawName;
  298|  4.74k|            fRawName = 0;
  299|  4.74k|            fRawNameBufSz = newLen + 8;
  300|  4.74k|            fRawName = (XMLCh*) fMemoryManager->allocate
  301|  4.74k|            (
  302|  4.74k|                (fRawNameBufSz + 1) * sizeof(XMLCh)
  303|  4.74k|            ); //new XMLCh[fRawNameBufSz + 1];
  304|  4.74k|        }
  305|  5.05k|        XMLString::moveChars(fRawName, rawName, newLen + 1);
  306|  5.05k|        setNPrefix(rawName, colonInd);
  307|  5.05k|    }
  308|  49.6k|    else
  309|  49.6k|    {
  310|       |        // No colon, so we just have a name with no prefix
  311|  49.6k|        setNPrefix(XMLUni::fgZeroLenString, 0);
  312|       |
  313|       |        // And clean up any QName and leave it undone until/if asked for again
  314|  49.6k|        if (fRawName)
  ------------------
  |  Branch (314:13): [True: 412, False: 49.2k]
  ------------------
  315|    412|            *fRawName = 0;
  316|  49.6k|    }
  317|       |
  318|  54.7k|    setNLocalPart(&rawName[colonInd+1], newLen-colonInd-1);
  319|       |
  320|       |    // And finally store the URI id parameter
  321|  54.7k|    fURIId = uriId;
  322|  54.7k|}
_ZN11xercesc_3_25QName10setNPrefixEPKDsm:
  325|   606k|{
  326|   606k|    if (!fPrefixBufSz || (newLen > fPrefixBufSz))
  ------------------
  |  Branch (326:9): [True: 89.5k, False: 516k]
  |  Branch (326:26): [True: 12, False: 516k]
  ------------------
  327|  89.5k|    {
  328|  89.5k|        fMemoryManager->deallocate(fPrefix); //delete [] fPrefix;
  329|  89.5k|        fPrefix = 0;
  330|  89.5k|        fPrefixBufSz = newLen + 8;
  331|  89.5k|        fPrefix = (XMLCh*) fMemoryManager->allocate
  332|  89.5k|        (
  333|  89.5k|            (fPrefixBufSz + 1) * sizeof(XMLCh)
  334|  89.5k|        ); //new XMLCh[fPrefixBufSz + 1];
  335|  89.5k|    }
  336|   606k|    XMLString::moveChars(fPrefix, prefix, newLen);
  337|   606k|    fPrefix[newLen] = chNull;
  338|   606k|}
_ZN11xercesc_3_25QName13setNLocalPartEPKDsm:
  341|   606k|{
  342|   606k|    if (!fLocalPartBufSz || (newLen > fLocalPartBufSz))
  ------------------
  |  Branch (342:9): [True: 89.5k, False: 516k]
  |  Branch (342:29): [True: 170, False: 516k]
  ------------------
  343|  89.6k|    {
  344|  89.6k|        fMemoryManager->deallocate(fLocalPart); //delete [] fLocalPart;
  345|  89.6k|        fLocalPart = 0;
  346|  89.6k|        fLocalPartBufSz = newLen + 8;
  347|  89.6k|        fLocalPart = (XMLCh*) fMemoryManager->allocate
  348|  89.6k|        (
  349|  89.6k|            (fLocalPartBufSz + 1) * sizeof(XMLCh)
  350|  89.6k|        ); //new XMLCh[fLocalPartBufSz + 1];
  351|  89.6k|    }
  352|   606k|    XMLString::moveChars(fLocalPart, localPart, newLen);
  353|   606k|    fLocalPart[newLen] = chNull;
  354|   606k|}
_ZN11xercesc_3_25QName9setValuesERKS0_:
  357|  31.3k|{
  358|  31.3k|    setPrefix(qname.getPrefix());
  359|  31.3k|    setLocalPart(qname.getLocalPart());
  360|  31.3k|    setURI(qname.getURI());
  361|  31.3k|}
_ZN11xercesc_3_25QName7cleanUpEv:
  383|  2.93M|{
  384|  2.93M|    fMemoryManager->deallocate(fLocalPart); //delete [] fLocalPart;
  385|  2.93M|    fMemoryManager->deallocate(fPrefix); //delete [] fPrefix;
  386|  2.93M|    fMemoryManager->deallocate(fRawName); //delete [] fRawName;
  387|  2.93M|    fLocalPart = fPrefix = fRawName = 0;
  388|  2.93M|}

_ZNK11xercesc_3_25QName9getPrefixEv:
  168|  3.14M|{
  169|  3.14M|	return fPrefix;
  170|  3.14M|}
_ZNK11xercesc_3_25QName12getLocalPartEv:
  178|  3.14M|{
  179|  3.14M|	return fLocalPart;
  180|  3.14M|}
_ZN11xercesc_3_25QName12getLocalPartEv:
  183|   473k|{
  184|   473k|	return fLocalPart;
  185|   473k|}
_ZNK11xercesc_3_25QName6getURIEv:
  188|  2.83M|{
  189|  2.83M|	return fURIId;
  190|  2.83M|}
_ZN11xercesc_3_25QName6setURIEj:
  201|  31.3k|{
  202|  31.3k|    fURIId = uriId;
  203|  31.3k|}
_ZN11xercesc_3_25QName9setPrefixEPKDs:
  206|   551k|{
  207|   551k|    setNPrefix(prefix, XMLString::stringLen(prefix));
  208|   551k|}
_ZN11xercesc_3_25QName12setLocalPartEPKDs:
  211|   551k|{
  212|   551k|    setNLocalPart(localPart, XMLString::stringLen(localPart));
  213|   551k|}

_ZN11xercesc_3_216RefArrayVectorOfIDsEC2EmbPNS_13MemoryManagerE:
   35|      1|{
   36|      1|}
_ZN11xercesc_3_216RefArrayVectorOfIDsED2Ev:
   40|      1|{
   41|      1|    if (this->fAdoptedElems)
  ------------------
  |  Branch (41:9): [True: 1, False: 0]
  ------------------
   42|      1|    {
   43|      2|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (43:35): [True: 1, False: 1]
  ------------------
   44|      1|            this->fMemoryManager->deallocate(this->fElemList[index]);//delete[] fElemList[index];
   45|      1|    }
   46|      1|    this->fMemoryManager->deallocate(this->fElemList);//delete [] fElemList;
   47|      1|}

_ZN11xercesc_3_229RefHash2KeysTableOfEnumeratorINS_12SchemaAttDefENS_12StringHasherEE8findNextEv:
  647|      1|{
  648|       |    //  Code to execute if we have to return only values with the primary key
  649|      1|    if(fLockPrimaryKey)
  ------------------
  |  Branch (649:8): [True: 0, False: 1]
  ------------------
  650|      0|    {
  651|      0|        if(!fCurElem)
  ------------------
  |  Branch (651:12): [True: 0, False: 0]
  ------------------
  652|      0|            fCurElem = fToEnum->fBucketList[fCurHash];
  653|      0|        else
  654|      0|            fCurElem = fCurElem->fNext;
  655|      0|        while (fCurElem && (!fToEnum->fHasher.equals(fLockPrimaryKey, fCurElem->fKey1)))
  ------------------
  |  Branch (655:16): [True: 0, False: 0]
  |  Branch (655:28): [True: 0, False: 0]
  ------------------
  656|      0|            fCurElem = fCurElem->fNext;
  657|       |        // if we didn't found it, make so hasMoreElements() returns false
  658|      0|        if(!fCurElem)
  ------------------
  |  Branch (658:12): [True: 0, False: 0]
  ------------------
  659|      0|            fCurHash = fToEnum->fHashModulus;
  660|      0|        return;
  661|      0|    }
  662|       |    //
  663|       |    //  If there is a current element, move to its next element. If this
  664|       |    //  hits the end of the bucket, the next block will handle the rest.
  665|       |    //
  666|      1|    if (fCurElem)
  ------------------
  |  Branch (666:9): [True: 0, False: 1]
  ------------------
  667|      0|        fCurElem = fCurElem->fNext;
  668|       |
  669|       |    //
  670|       |    //  If the current element is null, then we have to move up to the
  671|       |    //  next hash value. If that is the hash modulus, then we cannot
  672|       |    //  go further.
  673|       |    //
  674|      1|    if (!fCurElem)
  ------------------
  |  Branch (674:9): [True: 1, False: 0]
  ------------------
  675|      1|    {
  676|      1|        fCurHash++;
  677|      1|        if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (677:13): [True: 0, False: 1]
  ------------------
  678|      0|            return;
  679|       |
  680|       |        // Else find the next non-empty bucket
  681|     29|        while (fToEnum->fBucketList[fCurHash]==0)
  ------------------
  |  Branch (681:16): [True: 29, False: 0]
  ------------------
  682|     29|        {
  683|       |            // Bump to the next hash value. If we max out return
  684|     29|            fCurHash++;
  685|     29|            if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (685:17): [True: 1, False: 28]
  ------------------
  686|      1|                return;
  687|     29|        }
  688|      0|        fCurElem = fToEnum->fBucketList[fCurHash];
  689|      0|    }
  690|      1|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_12SchemaAttDefENS_12StringHasherEEC2EmbPNS_13MemoryManagerE:
   83|      1|{
   84|      1|    initialize(modulus);
   85|      1|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_12SchemaAttDefENS_12StringHasherEE10initializeEm:
  106|      1|{
  107|      1|    if (modulus == 0)
  ------------------
  |  Branch (107:9): [True: 0, False: 1]
  ------------------
  108|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  109|       |
  110|       |    // Allocate the bucket list and zero them
  111|      1|    fBucketList = (RefHash2KeysTableBucketElem<TVal>**) fMemoryManager->allocate
  112|      1|    (
  113|      1|        fHashModulus * sizeof(RefHash2KeysTableBucketElem<TVal>*)
  114|      1|    ); //new RefHash2KeysTableBucketElem<TVal>*[fHashModulus];
  115|      1|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
  116|      1|}
_ZN11xercesc_3_229RefHash2KeysTableOfEnumeratorINS_12SchemaAttDefENS_12StringHasherEEC2EPNS_19RefHash2KeysTableOfIS1_S2_EEbPNS_13MemoryManagerE:
  548|      1|{
  549|      1|    if (!toEnum)
  ------------------
  |  Branch (549:9): [True: 0, False: 1]
  ------------------
  550|      0|        ThrowXMLwithMemMgr(NullPointerException, XMLExcepts::CPtr_PointerIsZero, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  551|       |
  552|       |    //
  553|       |    //  Find the next available bucket element in the hash table. If it
  554|       |    //  comes back zero, that just means the table is empty.
  555|       |    //
  556|       |    //  Note that the -1 in the current hash tells it to start
  557|       |    //  from the beginning.
  558|       |    //
  559|      1|    findNext();
  560|      1|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10SchemaInfoENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|  17.0k|{
   52|  17.0k|    initialize(modulus);
   53|  17.0k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10SchemaInfoENS_12StringHasherEE10initializeEm:
  106|  17.0k|{
  107|  17.0k|    if (modulus == 0)
  ------------------
  |  Branch (107:9): [True: 0, False: 17.0k]
  ------------------
  108|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  109|       |
  110|       |    // Allocate the bucket list and zero them
  111|  17.0k|    fBucketList = (RefHash2KeysTableBucketElem<TVal>**) fMemoryManager->allocate
  112|  17.0k|    (
  113|  17.0k|        fHashModulus * sizeof(RefHash2KeysTableBucketElem<TVal>*)
  114|  17.0k|    ); //new RefHash2KeysTableBucketElem<TVal>*[fHashModulus];
  115|  17.0k|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
  116|  17.0k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10SchemaInfoENS_12StringHasherEED2Ev:
  120|  17.0k|{
  121|  17.0k|    removeAll();
  122|       |
  123|       |    // Then delete the bucket list & hasher
  124|  17.0k|    fMemoryManager->deallocate(fBucketList); //delete [] fBucketList;
  125|  17.0k|    fBucketList = 0;
  126|  17.0k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10SchemaInfoENS_12StringHasherEE9removeAllEv:
  254|  25.5k|{
  255|  25.5k|    if(isEmpty())
  ------------------
  |  Branch (255:8): [True: 25.5k, False: 0]
  ------------------
  256|  25.5k|        return;
  257|       |
  258|       |    // Clean up the buckets first
  259|      0|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (259:33): [True: 0, False: 0]
  ------------------
  260|      0|    {
  261|       |        // Get the bucket list head for this entry
  262|      0|        RefHash2KeysTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  263|      0|        RefHash2KeysTableBucketElem<TVal>* nextElem;
  264|      0|        while (curElem)
  ------------------
  |  Branch (264:16): [True: 0, False: 0]
  ------------------
  265|      0|        {
  266|       |            // Save the next element before we hose this one
  267|      0|            nextElem = curElem->fNext;
  268|       |
  269|       |            // If we adopted the data, then delete it too
  270|       |            //    (Note:  the userdata hash table instance has data type of void *.
  271|       |            //    This will generate compiler warnings here on some platforms, but they
  272|       |            //    can be ignored since fAdoptedElements is false.
  273|      0|            if (fAdoptedElems)
  ------------------
  |  Branch (273:17): [True: 0, False: 0]
  ------------------
  274|      0|                delete curElem->fData;
  275|       |
  276|       |            // Then delete the current element and move forward
  277|       |            // destructor is empty...
  278|       |            // curElem->~RefHash2KeysTableBucketElem();
  279|      0|            fMemoryManager->deallocate(curElem);
  280|      0|            curElem = nextElem;
  281|      0|        }
  282|       |
  283|       |        // Clean out this entry
  284|      0|        fBucketList[buckInd] = 0;
  285|      0|    }
  286|      0|    fCount=0;
  287|      0|}
_ZNK11xercesc_3_219RefHash2KeysTableOfINS_10SchemaInfoENS_12StringHasherEE7isEmptyEv:
  134|  25.5k|{
  135|  25.5k|    return (fCount==0);
  136|  25.5k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10ValueStoreENS_9PtrHasherEE9removeAllEv:
  254|  17.0k|{
  255|  17.0k|    if(isEmpty())
  ------------------
  |  Branch (255:8): [True: 17.0k, False: 0]
  ------------------
  256|  17.0k|        return;
  257|       |
  258|       |    // Clean up the buckets first
  259|      0|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (259:33): [True: 0, False: 0]
  ------------------
  260|      0|    {
  261|       |        // Get the bucket list head for this entry
  262|      0|        RefHash2KeysTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  263|      0|        RefHash2KeysTableBucketElem<TVal>* nextElem;
  264|      0|        while (curElem)
  ------------------
  |  Branch (264:16): [True: 0, False: 0]
  ------------------
  265|      0|        {
  266|       |            // Save the next element before we hose this one
  267|      0|            nextElem = curElem->fNext;
  268|       |
  269|       |            // If we adopted the data, then delete it too
  270|       |            //    (Note:  the userdata hash table instance has data type of void *.
  271|       |            //    This will generate compiler warnings here on some platforms, but they
  272|       |            //    can be ignored since fAdoptedElements is false.
  273|      0|            if (fAdoptedElems)
  ------------------
  |  Branch (273:17): [True: 0, False: 0]
  ------------------
  274|      0|                delete curElem->fData;
  275|       |
  276|       |            // Then delete the current element and move forward
  277|       |            // destructor is empty...
  278|       |            // curElem->~RefHash2KeysTableBucketElem();
  279|      0|            fMemoryManager->deallocate(curElem);
  280|      0|            curElem = nextElem;
  281|      0|        }
  282|       |
  283|       |        // Clean out this entry
  284|      0|        fBucketList[buckInd] = 0;
  285|      0|    }
  286|      0|    fCount=0;
  287|      0|}
_ZNK11xercesc_3_219RefHash2KeysTableOfINS_10ValueStoreENS_9PtrHasherEE7isEmptyEv:
  134|  17.0k|{
  135|  17.0k|    return (fCount==0);
  136|  17.0k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10ValueStoreENS_9PtrHasherEED2Ev:
  120|  8.51k|{
  121|  8.51k|    removeAll();
  122|       |
  123|       |    // Then delete the bucket list & hasher
  124|  8.51k|    fMemoryManager->deallocate(fBucketList); //delete [] fBucketList;
  125|  8.51k|    fBucketList = 0;
  126|  8.51k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10ValueStoreENS_9PtrHasherEEC2EmbPNS_13MemoryManagerE:
   83|  8.51k|{
   84|  8.51k|    initialize(modulus);
   85|  8.51k|}
_ZN11xercesc_3_219RefHash2KeysTableOfINS_10ValueStoreENS_9PtrHasherEE10initializeEm:
  106|  8.51k|{
  107|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (107:9): [True: 0, False: 8.51k]
  ------------------
  108|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  109|       |
  110|       |    // Allocate the bucket list and zero them
  111|  8.51k|    fBucketList = (RefHash2KeysTableBucketElem<TVal>**) fMemoryManager->allocate
  112|  8.51k|    (
  113|  8.51k|        fHashModulus * sizeof(RefHash2KeysTableBucketElem<TVal>*)
  114|  8.51k|    ); //new RefHash2KeysTableBucketElem<TVal>*[fHashModulus];
  115|  8.51k|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
  116|  8.51k|}

_ZN11xercesc_3_218RefHash3KeysIdPoolINS_17SchemaElementDeclENS_12StringHasherEE9removeAllEv:
  203|  8.51k|{
  204|  8.51k|    if (fIdCounter == 0) return;
  ------------------
  |  Branch (204:9): [True: 8.51k, False: 0]
  ------------------
  205|       |
  206|       |    // Clean up the buckets first
  207|      0|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (207:33): [True: 0, False: 0]
  ------------------
  208|      0|    {
  209|       |        // Get the bucket list head for this entry
  210|      0|        RefHash3KeysTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  211|      0|        RefHash3KeysTableBucketElem<TVal>* nextElem;
  212|      0|        while (curElem)
  ------------------
  |  Branch (212:16): [True: 0, False: 0]
  ------------------
  213|      0|        {
  214|       |            // Save the next element before we hose this one
  215|      0|            nextElem = curElem->fNext;
  216|       |
  217|       |            // If we adopted the data, then delete it too
  218|       |            //    (Note:  the userdata hash table instance has data type of void *.
  219|       |            //    This will generate compiler warnings here on some platforms, but they
  220|       |            //    can be ignored since fAdoptedElements is false.
  221|      0|            if (fAdoptedElems)
  ------------------
  |  Branch (221:17): [True: 0, False: 0]
  ------------------
  222|      0|                delete curElem->fData;
  223|       |
  224|       |            // Then delete the current element and move forward
  225|       |            // delete curElem;
  226|       |            // destructor is empty...
  227|       |            // curElem->~RefHash3KeysTableBucketElem();
  228|      0|            fMemoryManager->deallocate(curElem);
  229|      0|            curElem = nextElem;
  230|      0|        }
  231|       |
  232|       |        // Clean out this entry
  233|      0|        fBucketList[buckInd] = 0;
  234|      0|    }
  235|       |
  236|       |    // Reset the id counter
  237|      0|    fIdCounter = 0;
  238|      0|}
_ZN11xercesc_3_218RefHash3KeysIdPoolINS_17SchemaElementDeclENS_12StringHasherEE10initializeEm:
  152|  8.51k|{
  153|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (153:9): [True: 0, False: 8.51k]
  ------------------
  154|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  155|       |
  156|       |    // Allocate the bucket list and zero them
  157|  8.51k|    fBucketList = (RefHash3KeysTableBucketElem<TVal>**) fMemoryManager->allocate
  158|  8.51k|    (
  159|  8.51k|        fHashModulus * sizeof(RefHash3KeysTableBucketElem<TVal>*)
  160|  8.51k|    ); //new RefHash3KeysTableBucketElem<TVal>*[fHashModulus];
  161|  8.51k|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
  162|  8.51k|}
_ZN11xercesc_3_218RefHash3KeysIdPoolINS_17SchemaElementDeclENS_12StringHasherEED2Ev:
  166|  8.51k|{
  167|  8.51k|    removeAll();
  168|       |
  169|       |    // Then delete the bucket list & hasher & id pointers list
  170|  8.51k|    fMemoryManager->deallocate(fIdPtrs); //delete [] fIdPtrs;
  171|  8.51k|    fIdPtrs = 0;
  172|  8.51k|    fMemoryManager->deallocate(fBucketList); //delete [] fBucketList;
  173|  8.51k|    fBucketList = 0;
  174|  8.51k|}
_ZN11xercesc_3_218RefHash3KeysIdPoolINS_17SchemaElementDeclENS_12StringHasherEEC2EmbmPNS_13MemoryManagerE:
  108|  8.51k|{
  109|  8.51k|    initialize(modulus);
  110|       |
  111|       |    //  Allocate the initial id pointers array. We don't have to zero them
  112|       |    //  out since the fIdCounter value tells us which ones are valid. The
  113|       |    //  zeroth element is never used (and represents an invalid pool id.)
  114|       |    //
  115|  8.51k|    if (!fIdPtrsCount)
  ------------------
  |  Branch (115:9): [True: 0, False: 8.51k]
  ------------------
  116|      0|        fIdPtrsCount = 256;
  117|  8.51k|    fIdPtrs = (TVal**) fMemoryManager->allocate(fIdPtrsCount * sizeof(TVal*)); //new TVal*[fIdPtrsCount];
  118|  8.51k|    fIdPtrs[0] = 0;
  119|  8.51k|}

_ZN11xercesc_3_214RefHashTableOfINS_8ENameMapENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|      1|{
   52|      1|    initialize(modulus);
   53|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_8ENameMapENS_12StringHasherEE10initializeEm:
  109|      1|{
  110|      1|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 1]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|      1|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|      1|    (
  116|      1|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|      1|    );
  118|    104|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 103, False: 1]
  ------------------
  119|    103|        fBucketList[index] = 0;
  120|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_8ENameMapENS_12StringHasherEE3putEPvPS1_:
  396|     48|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|     48|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|     48|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 48]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|     48|    XMLSize_t hashVal;
  406|     48|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|     48|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 48]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|     48|    else
  420|     48|    {
  421|     48|        newBucket =
  422|     48|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|     48|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|     48|        fBucketList[hashVal] = newBucket;
  425|     48|        fCount++;
  426|     48|    }
  427|     48|}
_ZN11xercesc_3_214RefHashTableOfINS_8ENameMapENS_12StringHasherEE14findBucketElemEPKvRm:
  490|  8.34k|{
  491|       |    // Hash the key
  492|  8.34k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  8.34k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  8.61k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 1.23k, False: 7.37k]
  ------------------
  497|  1.23k|    {
  498|  1.23k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 969, False: 265]
  ------------------
  499|    969|            return curElem;
  500|       |
  501|    265|        curElem = curElem->fNext;
  502|    265|    }
  503|  7.37k|    return 0;
  504|  8.34k|}
_ZN11xercesc_3_214RefHashTableOfINS_8ENameMapENS_12StringHasherEE3getEPKv:
  349|  8.30k|{
  350|  8.30k|    XMLSize_t hashVal;
  351|  8.30k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  8.30k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 969, False: 7.33k]
  ------------------
  353|  8.30k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE3getEPKv:
  349|  68.2k|{
  350|  68.2k|    XMLSize_t hashVal;
  351|  68.2k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  68.2k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 146, False: 68.1k]
  ------------------
  353|  68.2k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE14findBucketElemEPKvRm:
  490|   136k|{
  491|       |    // Hash the key
  492|   136k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|   136k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|   136k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 146, False: 136k]
  ------------------
  497|    146|    {
  498|    146|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 146, False: 0]
  ------------------
  499|    146|            return curElem;
  500|       |
  501|      0|        curElem = curElem->fNext;
  502|      0|    }
  503|   136k|    return 0;
  504|   136k|}
_ZN11xercesc_3_214RefHashTableOfINS_12KVStringPairENS_12StringHasherEE10initializeEm:
  109|     20|{
  110|     20|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 20]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|     20|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|     20|    (
  116|     20|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|     20|    );
  118|     65|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 45, False: 20]
  ------------------
  119|     45|        fBucketList[index] = 0;
  120|     20|}
_ZN11xercesc_3_214RefHashTableOfINS_12KVStringPairENS_12StringHasherEE3getEPKv:
  349|    136|{
  350|    136|    XMLSize_t hashVal;
  351|    136|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|    136|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 15, False: 121]
  ------------------
  353|    136|}
_ZN11xercesc_3_214RefHashTableOfINS_12KVStringPairENS_12StringHasherEE14findBucketElemEPKvRm:
  490|    162|{
  491|       |    // Hash the key
  492|    162|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|    162|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|    210|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 63, False: 147]
  ------------------
  497|     63|    {
  498|     63|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 15, False: 48]
  ------------------
  499|     15|            return curElem;
  500|       |
  501|     48|        curElem = curElem->fNext;
  502|     48|    }
  503|    147|    return 0;
  504|    162|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_12KVStringPairENS_12StringHasherEEC2EPNS_14RefHashTableOfIS1_S2_EEbPNS_13MemoryManagerE:
  535|     20|{
  536|     20|    if (!toEnum)
  ------------------
  |  Branch (536:9): [True: 0, False: 20]
  ------------------
  537|      0|        ThrowXMLwithMemMgr(NullPointerException, XMLExcepts::CPtr_PointerIsZero, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  538|       |
  539|       |    //
  540|       |    //  Find the next available bucket element in the hash table. If it
  541|       |    //  comes back zero, that just means the table is empty.
  542|       |    //
  543|       |    //  Note that the -1 in the current hash tells it to start
  544|       |    //  from the beginning.
  545|       |    //
  546|     20|    findNext();
  547|     20|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_12KVStringPairENS_12StringHasherEE8findNextEv:
  632|     46|{
  633|       |    //
  634|       |    //  If there is a current element, move to its next element. If this
  635|       |    //  hits the end of the bucket, the next block will handle the rest.
  636|       |    //
  637|     46|    if (fCurElem)
  ------------------
  |  Branch (637:9): [True: 26, False: 20]
  ------------------
  638|     26|        fCurElem = fCurElem->fNext;
  639|       |
  640|       |    //
  641|       |    //  If the current element is null, then we have to move up to the
  642|       |    //  next hash value. If that is the hash modulus, then we cannot
  643|       |    //  go further.
  644|       |    //
  645|     46|    if (!fCurElem)
  ------------------
  |  Branch (645:9): [True: 45, False: 1]
  ------------------
  646|     45|    {
  647|     45|        fCurHash++;
  648|     45|        if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (648:13): [True: 7, False: 38]
  ------------------
  649|      7|            return;
  650|       |
  651|       |        // Else find the next non-empty bucket
  652|     57|        while (fToEnum->fBucketList[fCurHash]==0)
  ------------------
  |  Branch (652:16): [True: 32, False: 25]
  ------------------
  653|     32|        {
  654|       |            // Bump to the next hash value. If we max out return
  655|     32|            fCurHash++;
  656|     32|            if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (656:17): [True: 13, False: 19]
  ------------------
  657|     13|                return;
  658|     32|        }
  659|     25|        fCurElem = fToEnum->fBucketList[fCurHash];
  660|     25|    }
  661|     46|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_12KVStringPairENS_12StringHasherEED2Ev:
  551|     20|{
  552|     20|    if (fAdopted)
  ------------------
  |  Branch (552:9): [True: 0, False: 20]
  ------------------
  553|      0|        delete fToEnum;
  554|     20|}
_ZNK11xercesc_3_224RefHashTableOfEnumeratorINS_12KVStringPairENS_12StringHasherEE15hasMoreElementsEv:
  573|     72|{
  574|       |    //
  575|       |    //  If our current has is at the max and there are no more elements
  576|       |    //  in the current bucket, then no more elements.
  577|       |    //
  578|     72|    if (!fCurElem && (fCurHash == fToEnum->fHashModulus))
  ------------------
  |  Branch (578:9): [True: 20, False: 52]
  |  Branch (578:22): [True: 20, False: 0]
  ------------------
  579|     20|        return false;
  580|     52|    return true;
  581|     72|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_12KVStringPairENS_12StringHasherEE11nextElementEv:
  585|     26|{
  586|       |    // Make sure we have an element to return
  587|     26|    if (!hasMoreElements())
  ------------------
  |  Branch (587:9): [True: 0, False: 26]
  ------------------
  588|      0|        ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::Enum_NoMoreElements, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  589|       |
  590|       |    //
  591|       |    //  Save the current element, then move up to the next one for the
  592|       |    //  next time around.
  593|       |    //
  594|     26|    RefHashTableBucketElem<TVal>* saveElem = fCurElem;
  595|     26|    findNext();
  596|       |
  597|     26|    return *saveElem->fData;
  598|     26|}
_ZN11xercesc_3_214RefHashTableOfINS_12KVStringPairENS_12StringHasherEE3putEPvPS1_:
  396|     26|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|     26|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|     26|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 4, False: 22]
  ------------------
  402|      4|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|     26|    XMLSize_t hashVal;
  406|     26|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|     26|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 26]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|     26|    else
  420|     26|    {
  421|     26|        newBucket =
  422|     26|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|     26|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|     26|        fBucketList[hashVal] = newBucket;
  425|     26|        fCount++;
  426|     26|    }
  427|     26|}
_ZN11xercesc_3_214RefHashTableOfINS_12KVStringPairENS_12StringHasherEE6rehashEv:
  436|      4|{
  437|      4|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|      4|    RefHashTableBucketElem<TVal>** newBucketList =
  440|      4|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|      4|    (
  442|      4|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|      4|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|      4|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|      4|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|     12|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 8, False: 4]
  ------------------
  454|      8|    {
  455|       |        // Get the bucket list head for this entry
  456|      8|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|     12|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 4, False: 8]
  ------------------
  459|      4|        {
  460|       |            // Save the next element before we detach this one
  461|      4|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|      4|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|      4|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|      4|            curElem->fNext = newHeadElem;
  469|      4|            newBucketList[hashVal] = curElem;
  470|       |
  471|      4|            curElem = nextElem;
  472|      4|        }
  473|      8|    }
  474|       |
  475|      4|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|      4|    fBucketList = guard.release();
  480|      4|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|      4|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|      4|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_10XMLRefInfoENS_12StringHasherEEC2EPNS_14RefHashTableOfIS1_S2_EEbPNS_13MemoryManagerE:
  535|  1.42k|{
  536|  1.42k|    if (!toEnum)
  ------------------
  |  Branch (536:9): [True: 0, False: 1.42k]
  ------------------
  537|      0|        ThrowXMLwithMemMgr(NullPointerException, XMLExcepts::CPtr_PointerIsZero, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  538|       |
  539|       |    //
  540|       |    //  Find the next available bucket element in the hash table. If it
  541|       |    //  comes back zero, that just means the table is empty.
  542|       |    //
  543|       |    //  Note that the -1 in the current hash tells it to start
  544|       |    //  from the beginning.
  545|       |    //
  546|  1.42k|    findNext();
  547|  1.42k|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_10XMLRefInfoENS_12StringHasherEE8findNextEv:
  632|  2.53k|{
  633|       |    //
  634|       |    //  If there is a current element, move to its next element. If this
  635|       |    //  hits the end of the bucket, the next block will handle the rest.
  636|       |    //
  637|  2.53k|    if (fCurElem)
  ------------------
  |  Branch (637:9): [True: 1.10k, False: 1.42k]
  ------------------
  638|  1.10k|        fCurElem = fCurElem->fNext;
  639|       |
  640|       |    //
  641|       |    //  If the current element is null, then we have to move up to the
  642|       |    //  next hash value. If that is the hash modulus, then we cannot
  643|       |    //  go further.
  644|       |    //
  645|  2.53k|    if (!fCurElem)
  ------------------
  |  Branch (645:9): [True: 2.32k, False: 212]
  ------------------
  646|  2.32k|    {
  647|  2.32k|        fCurHash++;
  648|  2.32k|        if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (648:13): [True: 7, False: 2.31k]
  ------------------
  649|      7|            return;
  650|       |
  651|       |        // Else find the next non-empty bucket
  652|   156k|        while (fToEnum->fBucketList[fCurHash]==0)
  ------------------
  |  Branch (652:16): [True: 155k, False: 891]
  ------------------
  653|   155k|        {
  654|       |            // Bump to the next hash value. If we max out return
  655|   155k|            fCurHash++;
  656|   155k|            if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (656:17): [True: 1.42k, False: 154k]
  ------------------
  657|  1.42k|                return;
  658|   155k|        }
  659|    891|        fCurElem = fToEnum->fBucketList[fCurHash];
  660|    891|    }
  661|  2.53k|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_10XMLRefInfoENS_12StringHasherEED2Ev:
  551|  1.42k|{
  552|  1.42k|    if (fAdopted)
  ------------------
  |  Branch (552:9): [True: 0, False: 1.42k]
  ------------------
  553|      0|        delete fToEnum;
  554|  1.42k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEED2Ev:
  124|  8.51k|{
  125|  8.51k|    cleanup();
  126|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE7cleanupEv:
  302|  8.51k|{
  303|  8.51k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  8.51k|    fMemoryManager->deallocate(fBucketList);
  307|  8.51k|    fBucketList = 0;
  308|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE9removeAllEv:
  203|  17.0k|{
  204|  17.0k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 16.7k, False: 271]
  ------------------
  205|  16.7k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|  34.9k|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 34.7k, False: 271]
  ------------------
  209|  34.7k|    {
  210|       |        // Get the bucket list head for this entry
  211|  34.7k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|  34.7k|        RefHashTableBucketElem<TVal>* nextElem;
  213|  40.0k|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 5.31k, False: 34.7k]
  ------------------
  214|  5.31k|        {
  215|       |            // Save the next element before we hose this one
  216|  5.31k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  5.31k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 5.31k, False: 0]
  ------------------
  223|  5.31k|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  5.31k|            fMemoryManager->deallocate(curElem);
  230|  5.31k|            curElem = nextElem;
  231|  5.31k|        }
  232|       |
  233|       |        // Clean out this entry
  234|  34.7k|        fBucketList[buckInd] = 0;
  235|  34.7k|    }
  236|       |
  237|    271|    fCount = 0;
  238|    271|}
_ZNK11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE7isEmptyEv:
  134|  17.0k|{
  135|  17.0k|    return fCount==0;
  136|  17.0k|}
_ZNK11xercesc_3_224RefHashTableOfEnumeratorINS_10XMLRefInfoENS_12StringHasherEE15hasMoreElementsEv:
  573|  3.63k|{
  574|       |    //
  575|       |    //  If our current has is at the max and there are no more elements
  576|       |    //  in the current bucket, then no more elements.
  577|       |    //
  578|  3.63k|    if (!fCurElem && (fCurHash == fToEnum->fHashModulus))
  ------------------
  |  Branch (578:9): [True: 1.42k, False: 2.20k]
  |  Branch (578:22): [True: 1.42k, False: 0]
  ------------------
  579|  1.42k|        return false;
  580|  2.20k|    return true;
  581|  3.63k|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_10XMLRefInfoENS_12StringHasherEE11nextElementEv:
  585|  1.10k|{
  586|       |    // Make sure we have an element to return
  587|  1.10k|    if (!hasMoreElements())
  ------------------
  |  Branch (587:9): [True: 0, False: 1.10k]
  ------------------
  588|      0|        ThrowXMLwithMemMgr(NoSuchElementException, XMLExcepts::Enum_NoMoreElements, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  589|       |
  590|       |    //
  591|       |    //  Save the current element, then move up to the next one for the
  592|       |    //  next time around.
  593|       |    //
  594|  1.10k|    RefHashTableBucketElem<TVal>* saveElem = fCurElem;
  595|  1.10k|    findNext();
  596|       |
  597|  1.10k|    return *saveElem->fData;
  598|  1.10k|}
_ZNK11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE11containsKeyEPKv:
  140|     42|{
  141|     42|    XMLSize_t hashVal;
  142|     42|    const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  143|     42|    return (findIt != 0);
  144|     42|}
_ZNK11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE14findBucketElemEPKvRm:
  509|     42|{
  510|       |    // Hash the key
  511|     42|    hashVal = fHasher.getHashVal(key, fHashModulus);
  512|       |
  513|       |    // Search that bucket for the key
  514|     42|    const RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  515|     49|    while (curElem)
  ------------------
  |  Branch (515:12): [True: 49, False: 0]
  ------------------
  516|     49|    {
  517|     49|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (517:13): [True: 42, False: 7]
  ------------------
  518|     42|            return curElem;
  519|       |
  520|      7|        curElem = curElem->fNext;
  521|      7|    }
  522|      0|    return 0;
  523|     42|}
_ZN11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE3getEPKv:
  349|     42|{
  350|     42|    XMLSize_t hashVal;
  351|     42|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|     42|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 42, False: 0]
  ------------------
  353|     42|}
_ZN11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE14findBucketElemEPKvRm:
  490|     87|{
  491|       |    // Hash the key
  492|     87|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|     87|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|    119|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 74, False: 45]
  ------------------
  497|     74|    {
  498|     74|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 42, False: 32]
  ------------------
  499|     42|            return curElem;
  500|       |
  501|     32|        curElem = curElem->fNext;
  502|     32|    }
  503|     45|    return 0;
  504|     87|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEEC2EmbPNS_13MemoryManagerE:
   85|  25.5k|{
   86|  25.5k|    initialize(modulus);
   87|  25.5k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE10initializeEm:
  109|  25.5k|{
  110|  25.5k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 25.5k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  25.5k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  25.5k|    (
  116|  25.5k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  25.5k|    );
  118|   766k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 740k, False: 25.5k]
  ------------------
  119|   740k|        fBucketList[index] = 0;
  120|  25.5k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEED2Ev:
  124|  25.5k|{
  125|  25.5k|    cleanup();
  126|  25.5k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE7cleanupEv:
  302|  25.5k|{
  303|  25.5k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  25.5k|    fMemoryManager->deallocate(fBucketList);
  307|  25.5k|    fBucketList = 0;
  308|  25.5k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE3getEPKv:
  349|  16.8k|{
  350|  16.8k|    XMLSize_t hashVal;
  351|  16.8k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  16.8k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 8.31k, False: 8.51k]
  ------------------
  353|  16.8k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE14findBucketElemEPKvRm:
  490|  25.3k|{
  491|       |    // Hash the key
  492|  25.3k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  25.3k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  25.3k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 8.31k, False: 17.0k]
  ------------------
  497|  8.31k|    {
  498|  8.31k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 8.31k, False: 0]
  ------------------
  499|  8.31k|            return curElem;
  500|       |
  501|      0|        curElem = curElem->fNext;
  502|      0|    }
  503|  17.0k|    return 0;
  504|  25.3k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE3putEPvPS1_:
  396|  8.51k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  8.51k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  8.51k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 8.51k]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  8.51k|    XMLSize_t hashVal;
  406|  8.51k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  8.51k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 8.51k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  8.51k|    else
  420|  8.51k|    {
  421|  8.51k|        newBucket =
  422|  8.51k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  8.51k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  8.51k|        fBucketList[hashVal] = newBucket;
  425|  8.51k|        fCount++;
  426|  8.51k|    }
  427|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE9removeAllEv:
  203|  34.0k|{
  204|  34.0k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 25.5k, False: 8.51k]
  ------------------
  205|  25.5k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|   255k|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 246k, False: 8.51k]
  ------------------
  209|   246k|    {
  210|       |        // Get the bucket list head for this entry
  211|   246k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|   246k|        RefHashTableBucketElem<TVal>* nextElem;
  213|   255k|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 8.51k, False: 246k]
  ------------------
  214|  8.51k|        {
  215|       |            // Save the next element before we hose this one
  216|  8.51k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  8.51k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 8.51k, False: 0]
  ------------------
  223|  8.51k|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  8.51k|            fMemoryManager->deallocate(curElem);
  230|  8.51k|            curElem = nextElem;
  231|  8.51k|        }
  232|       |
  233|       |        // Clean out this entry
  234|   246k|        fBucketList[buckInd] = 0;
  235|   246k|    }
  236|       |
  237|  8.51k|    fCount = 0;
  238|  8.51k|}
_ZNK11xercesc_3_214RefHashTableOfINS_7GrammarENS_12StringHasherEE7isEmptyEv:
  134|  34.0k|{
  135|  34.0k|    return fCount==0;
  136|  34.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE3getEPKv:
  349|  1.47k|{
  350|  1.47k|    XMLSize_t hashVal;
  351|  1.47k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  1.47k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 1.14k, False: 336]
  ------------------
  353|  1.47k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE14findBucketElemEPKvRm:
  490|  3.34k|{
  491|       |    // Hash the key
  492|  3.34k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  3.34k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  4.24k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 2.05k, False: 2.19k]
  ------------------
  497|  2.05k|    {
  498|  2.05k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 1.14k, False: 907]
  ------------------
  499|  1.14k|            return curElem;
  500|       |
  501|    907|        curElem = curElem->fNext;
  502|    907|    }
  503|  2.19k|    return 0;
  504|  3.34k|}
_ZNK11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE11containsKeyEPKv:
  140|    317|{
  141|    317|    XMLSize_t hashVal;
  142|    317|    const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  143|    317|    return (findIt != 0);
  144|    317|}
_ZNK11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE14findBucketElemEPKvRm:
  509|    317|{
  510|       |    // Hash the key
  511|    317|    hashVal = fHasher.getHashVal(key, fHashModulus);
  512|       |
  513|       |    // Search that bucket for the key
  514|    317|    const RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  515|    604|    while (curElem)
  ------------------
  |  Branch (515:12): [True: 287, False: 317]
  ------------------
  516|    287|    {
  517|    287|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (517:13): [True: 0, False: 287]
  ------------------
  518|      0|            return curElem;
  519|       |
  520|    287|        curElem = curElem->fNext;
  521|    287|    }
  522|    317|    return 0;
  523|    317|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE3putEPvPS1_:
  396|  1.86k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  1.86k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  1.86k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 1.86k]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  1.86k|    XMLSize_t hashVal;
  406|  1.86k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  1.86k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 1.86k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  1.86k|    else
  420|  1.86k|    {
  421|  1.86k|        newBucket =
  422|  1.86k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  1.86k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  1.86k|        fBucketList[hashVal] = newBucket;
  425|  1.86k|        fCount++;
  426|  1.86k|    }
  427|  1.86k|}
_ZN11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|      1|{
   52|      1|    initialize(modulus);
   53|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE10initializeEm:
  109|      1|{
  110|      1|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 1]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|      1|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|      1|    (
  116|      1|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|      1|    );
  118|     30|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 29, False: 1]
  ------------------
  119|     29|        fBucketList[index] = 0;
  120|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE3putEPvPS1_:
  396|     45|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|     45|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|     45|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 2, False: 43]
  ------------------
  402|      2|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|     45|    XMLSize_t hashVal;
  406|     45|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|     45|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 45]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|     45|    else
  420|     45|    {
  421|     45|        newBucket =
  422|     45|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|     45|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|     45|        fBucketList[hashVal] = newBucket;
  425|     45|        fCount++;
  426|     45|    }
  427|     45|}
_ZN11xercesc_3_214RefHashTableOfINS_17DatatypeValidatorENS_12StringHasherEE6rehashEv:
  436|      2|{
  437|      2|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|      2|    RefHashTableBucketElem<TVal>** newBucketList =
  440|      2|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|      2|    (
  442|      2|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|      2|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|      2|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|      2|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|     90|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 88, False: 2]
  ------------------
  454|     88|    {
  455|       |        // Get the bucket list head for this entry
  456|     88|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|    153|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 65, False: 88]
  ------------------
  459|     65|        {
  460|       |            // Save the next element before we detach this one
  461|     65|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|     65|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|     65|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|     65|            curElem->fNext = newHeadElem;
  469|     65|            newBucketList[hashVal] = curElem;
  470|       |
  471|     65|            curElem = nextElem;
  472|     65|        }
  473|     88|    }
  474|       |
  475|      2|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|      2|    fBucketList = guard.release();
  480|      2|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|      2|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|      2|}
_ZN11xercesc_3_214RefHashTableOfINS_12KVStringPairENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|     20|{
   52|     20|    initialize(modulus);
   53|     20|}
_ZN11xercesc_3_214RefHashTableOfINS_14XMLCanRepGroupENS_9PtrHasherEEC2EmbPNS_13MemoryManagerE:
   85|      1|{
   86|      1|    initialize(modulus);
   87|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_14XMLCanRepGroupENS_9PtrHasherEE10initializeEm:
  109|      1|{
  110|      1|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 1]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|      1|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|      1|    (
  116|      1|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|      1|    );
  118|     30|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 29, False: 1]
  ------------------
  119|     29|        fBucketList[index] = 0;
  120|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_14XMLCanRepGroupENS_9PtrHasherEE3putEPvPS1_:
  396|     14|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|     14|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|     14|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 14]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|     14|    XMLSize_t hashVal;
  406|     14|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|     14|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 14]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|     14|    else
  420|     14|    {
  421|     14|        newBucket =
  422|     14|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|     14|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|     14|        fBucketList[hashVal] = newBucket;
  425|     14|        fCount++;
  426|     14|    }
  427|     14|}
_ZN11xercesc_3_214RefHashTableOfINS_14XMLCanRepGroupENS_9PtrHasherEE14findBucketElemEPKvRm:
  490|     14|{
  491|       |    // Hash the key
  492|     14|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|     14|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|     15|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 1, False: 14]
  ------------------
  497|      1|    {
  498|      1|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 0, False: 1]
  ------------------
  499|      0|            return curElem;
  500|       |
  501|      1|        curElem = curElem->fNext;
  502|      1|    }
  503|     14|    return 0;
  504|     14|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE3getEPKv:
  349|  2.51M|{
  350|  2.51M|    XMLSize_t hashVal;
  351|  2.51M|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  2.51M|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 2.03M, False: 480k]
  ------------------
  353|  2.51M|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE14findBucketElemEPKvRm:
  490|  2.56M|{
  491|       |    // Hash the key
  492|  2.56M|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  2.56M|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  3.03M|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 2.50M, False: 533k]
  ------------------
  497|  2.50M|    {
  498|  2.50M|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 2.03M, False: 472k]
  ------------------
  499|  2.03M|            return curElem;
  500|       |
  501|   472k|        curElem = curElem->fNext;
  502|   472k|    }
  503|   533k|    return 0;
  504|  2.56M|}
_ZNK11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE11containsKeyEPKv:
  140|    617|{
  141|    617|    XMLSize_t hashVal;
  142|    617|    const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  143|    617|    return (findIt != 0);
  144|    617|}
_ZNK11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE14findBucketElemEPKvRm:
  509|    617|{
  510|       |    // Hash the key
  511|    617|    hashVal = fHasher.getHashVal(key, fHashModulus);
  512|       |
  513|       |    // Search that bucket for the key
  514|    617|    const RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  515|    918|    while (curElem)
  ------------------
  |  Branch (515:12): [True: 301, False: 617]
  ------------------
  516|    301|    {
  517|    301|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (517:13): [True: 0, False: 301]
  ------------------
  518|      0|            return curElem;
  519|       |
  520|    301|        curElem = curElem->fNext;
  521|    301|    }
  522|    617|    return 0;
  523|    617|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE3putEPvPS1_:
  396|  2.89k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  2.89k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  2.89k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 2.89k]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  2.89k|    XMLSize_t hashVal;
  406|  2.89k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  2.89k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 2.89k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  2.89k|    else
  420|  2.89k|    {
  421|  2.89k|        newBucket =
  422|  2.89k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  2.89k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  2.89k|        fBucketList[hashVal] = newBucket;
  425|  2.89k|        fCount++;
  426|  2.89k|    }
  427|  2.89k|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE14findBucketElemEPKvRm:
  490|  75.3k|{
  491|       |    // Hash the key
  492|  75.3k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  75.3k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  94.3k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 41.9k, False: 52.4k]
  ------------------
  497|  41.9k|    {
  498|  41.9k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 22.9k, False: 19.0k]
  ------------------
  499|  22.9k|            return curElem;
  500|       |
  501|  19.0k|        curElem = curElem->fNext;
  502|  19.0k|    }
  503|  52.4k|    return 0;
  504|  75.3k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|  17.0k|{
   52|  17.0k|    initialize(modulus);
   53|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE10initializeEm:
  109|  17.0k|{
  110|  17.0k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 17.0k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  17.0k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  17.0k|    (
  116|  17.0k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  17.0k|    );
  118|  1.19M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 1.17M, False: 17.0k]
  ------------------
  119|  1.17M|        fBucketList[index] = 0;
  120|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEED2Ev:
  124|  17.0k|{
  125|  17.0k|    cleanup();
  126|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE7cleanupEv:
  302|  17.0k|{
  303|  17.0k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  17.0k|    fMemoryManager->deallocate(fBucketList);
  307|  17.0k|    fBucketList = 0;
  308|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE9removeAllEv:
  203|  17.0k|{
  204|  17.0k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 6.13k, False: 10.8k]
  ------------------
  205|  6.13k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|  1.00M|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 992k, False: 10.8k]
  ------------------
  209|   992k|    {
  210|       |        // Get the bucket list head for this entry
  211|   992k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|   992k|        RefHashTableBucketElem<TVal>* nextElem;
  213|  1.04M|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 52.6k, False: 992k]
  ------------------
  214|  52.6k|        {
  215|       |            // Save the next element before we hose this one
  216|  52.6k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  52.6k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 52.6k, False: 0]
  ------------------
  223|  52.6k|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  52.6k|            fMemoryManager->deallocate(curElem);
  230|  52.6k|            curElem = nextElem;
  231|  52.6k|        }
  232|       |
  233|       |        // Clean out this entry
  234|   992k|        fBucketList[buckInd] = 0;
  235|   992k|    }
  236|       |
  237|  10.8k|    fCount = 0;
  238|  10.8k|}
_ZNK11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE7isEmptyEv:
  134|  17.0k|{
  135|  17.0k|    return fCount==0;
  136|  17.0k|}
_ZNK11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE11containsKeyEPKv:
  140|  41.7k|{
  141|  41.7k|    XMLSize_t hashVal;
  142|  41.7k|    const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  143|  41.7k|    return (findIt != 0);
  144|  41.7k|}
_ZNK11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE14findBucketElemEPKvRm:
  509|  41.7k|{
  510|       |    // Hash the key
  511|  41.7k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  512|       |
  513|       |    // Search that bucket for the key
  514|  41.7k|    const RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  515|  49.1k|    while (curElem)
  ------------------
  |  Branch (515:12): [True: 7.45k, False: 41.7k]
  ------------------
  516|  7.45k|    {
  517|  7.45k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (517:13): [True: 0, False: 7.45k]
  ------------------
  518|      0|            return curElem;
  519|       |
  520|  7.45k|        curElem = curElem->fNext;
  521|  7.45k|    }
  522|  41.7k|    return 0;
  523|  41.7k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE3putEPvPS1_:
  396|  52.6k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  52.6k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  52.6k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 115, False: 52.5k]
  ------------------
  402|    115|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  52.6k|    XMLSize_t hashVal;
  406|  52.6k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  52.6k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 52.6k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  52.6k|    else
  420|  52.6k|    {
  421|  52.6k|        newBucket =
  422|  52.6k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  52.6k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  52.6k|        fBucketList[hashVal] = newBucket;
  425|  52.6k|        fCount++;
  426|  52.6k|    }
  427|  52.6k|}
_ZN11xercesc_3_214RefHashTableOfINS_14DTDElementDeclENS_12StringHasherEE6rehashEv:
  436|    115|{
  437|    115|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|    115|    RefHashTableBucketElem<TVal>** newBucketList =
  440|    115|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|    115|    (
  442|    115|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|    115|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|    115|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|    115|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|  11.6k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 11.5k, False: 115]
  ------------------
  454|  11.5k|    {
  455|       |        // Get the bucket list head for this entry
  456|  11.5k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|  20.1k|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 8.58k, False: 11.5k]
  ------------------
  459|  8.58k|        {
  460|       |            // Save the next element before we detach this one
  461|  8.58k|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|  8.58k|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|  8.58k|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|  8.58k|            curElem->fNext = newHeadElem;
  469|  8.58k|            newBucketList[hashVal] = curElem;
  470|       |
  471|  8.58k|            curElem = nextElem;
  472|  8.58k|        }
  473|  11.5k|    }
  474|       |
  475|    115|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|    115|    fBucketList = guard.release();
  480|    115|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|    115|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|    115|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|  16.8k|{
   52|  16.8k|    initialize(modulus);
   53|  16.8k|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE10initializeEm:
  109|  16.8k|{
  110|  16.8k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 16.8k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  16.8k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  16.8k|    (
  116|  16.8k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  16.8k|    );
  118|  1.85M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 1.83M, False: 16.8k]
  ------------------
  119|  1.83M|        fBucketList[index] = 0;
  120|  16.8k|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEED2Ev:
  124|  16.8k|{
  125|  16.8k|    cleanup();
  126|  16.8k|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE7cleanupEv:
  302|  16.8k|{
  303|  16.8k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  16.8k|    fMemoryManager->deallocate(fBucketList);
  307|  16.8k|    fBucketList = 0;
  308|  16.8k|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE9removeAllEv:
  203|  16.8k|{
  204|  16.8k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 14.5k, False: 2.27k]
  ------------------
  205|  14.5k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|   249k|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 247k, False: 2.27k]
  ------------------
  209|   247k|    {
  210|       |        // Get the bucket list head for this entry
  211|   247k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|   247k|        RefHashTableBucketElem<TVal>* nextElem;
  213|   250k|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 2.88k, False: 247k]
  ------------------
  214|  2.88k|        {
  215|       |            // Save the next element before we hose this one
  216|  2.88k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  2.88k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 2.88k, False: 0]
  ------------------
  223|  2.88k|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  2.88k|            fMemoryManager->deallocate(curElem);
  230|  2.88k|            curElem = nextElem;
  231|  2.88k|        }
  232|       |
  233|       |        // Clean out this entry
  234|   247k|        fBucketList[buckInd] = 0;
  235|   247k|    }
  236|       |
  237|  2.27k|    fCount = 0;
  238|  2.27k|}
_ZNK11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE7isEmptyEv:
  134|  16.8k|{
  135|  16.8k|    return fCount==0;
  136|  16.8k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|  8.51k|{
   52|  8.51k|    initialize(modulus);
   53|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE10initializeEm:
  109|  8.51k|{
  110|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 8.51k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  8.51k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  8.51k|    (
  116|  8.51k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  8.51k|    );
  118|   936k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 928k, False: 8.51k]
  ------------------
  119|   928k|        fBucketList[index] = 0;
  120|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEED2Ev:
  124|  8.51k|{
  125|  8.51k|    cleanup();
  126|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE7cleanupEv:
  302|  8.51k|{
  303|  8.51k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  8.51k|    fMemoryManager->deallocate(fBucketList);
  307|  8.51k|    fBucketList = 0;
  308|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE9removeAllEv:
  203|  8.51k|{
  204|  8.51k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 6.97k, False: 1.54k]
  ------------------
  205|  6.97k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|   169k|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 168k, False: 1.54k]
  ------------------
  209|   168k|    {
  210|       |        // Get the bucket list head for this entry
  211|   168k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|   168k|        RefHashTableBucketElem<TVal>* nextElem;
  213|   170k|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 1.86k, False: 168k]
  ------------------
  214|  1.86k|        {
  215|       |            // Save the next element before we hose this one
  216|  1.86k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  1.86k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 1.86k, False: 0]
  ------------------
  223|  1.86k|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  1.86k|            fMemoryManager->deallocate(curElem);
  230|  1.86k|            curElem = nextElem;
  231|  1.86k|        }
  232|       |
  233|       |        // Clean out this entry
  234|   168k|        fBucketList[buckInd] = 0;
  235|   168k|    }
  236|       |
  237|  1.54k|    fCount = 0;
  238|  1.54k|}
_ZNK11xercesc_3_214RefHashTableOfINS_15XMLNotationDeclENS_12StringHasherEE7isEmptyEv:
  134|  8.51k|{
  135|  8.51k|    return fCount==0;
  136|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_13DTDEntityDeclENS_12StringHasherEE3getEPKv:
  349|  72.4k|{
  350|  72.4k|    XMLSize_t hashVal;
  351|  72.4k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  72.4k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 22.9k, False: 49.5k]
  ------------------
  353|  72.4k|}
_ZN11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|      1|{
   52|      1|    initialize(modulus);
   53|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE10initializeEm:
  109|      1|{
  110|      1|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 1]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|      1|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|      1|    (
  116|      1|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|      1|    );
  118|    110|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 109, False: 1]
  ------------------
  119|    109|        fBucketList[index] = 0;
  120|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_12RangeFactoryENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|      1|{
   52|      1|    initialize(modulus);
   53|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_12RangeFactoryENS_12StringHasherEE10initializeEm:
  109|      1|{
  110|      1|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 1]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|      1|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|      1|    (
  116|      1|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|      1|    );
  118|     30|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 29, False: 1]
  ------------------
  119|     29|        fBucketList[index] = 0;
  120|      1|}
_ZNK11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE11containsKeyEPKv:
  140|    436|{
  141|    436|    XMLSize_t hashVal;
  142|    436|    const RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  143|    436|    return (findIt != 0);
  144|    436|}
_ZNK11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE14findBucketElemEPKvRm:
  509|    436|{
  510|       |    // Hash the key
  511|    436|    hashVal = fHasher.getHashVal(key, fHashModulus);
  512|       |
  513|       |    // Search that bucket for the key
  514|    436|    const RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  515|    574|    while (curElem)
  ------------------
  |  Branch (515:12): [True: 428, False: 146]
  ------------------
  516|    428|    {
  517|    428|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (517:13): [True: 290, False: 138]
  ------------------
  518|    290|            return curElem;
  519|       |
  520|    138|        curElem = curElem->fNext;
  521|    138|    }
  522|    146|    return 0;
  523|    436|}
_ZN11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE3getEPKv:
  349|    290|{
  350|    290|    XMLSize_t hashVal;
  351|    290|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|    290|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 290, False: 0]
  ------------------
  353|    290|}
_ZN11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE14findBucketElemEPKvRm:
  490|    436|{
  491|       |    // Hash the key
  492|    436|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|    436|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|    574|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 428, False: 146]
  ------------------
  497|    428|    {
  498|    428|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 290, False: 138]
  ------------------
  499|    290|            return curElem;
  500|       |
  501|    138|        curElem = curElem->fNext;
  502|    138|    }
  503|    146|    return 0;
  504|    436|}
_ZN11xercesc_3_214RefHashTableOfINS_12RangeFactoryENS_12StringHasherEE3getEPKv:
  349|      4|{
  350|      4|    XMLSize_t hashVal;
  351|      4|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|      4|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 4, False: 0]
  ------------------
  353|      4|}
_ZN11xercesc_3_214RefHashTableOfINS_12RangeFactoryENS_12StringHasherEE14findBucketElemEPKvRm:
  490|      8|{
  491|       |    // Hash the key
  492|      8|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|      8|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|     10|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 6, False: 4]
  ------------------
  497|      6|    {
  498|      6|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 4, False: 2]
  ------------------
  499|      4|            return curElem;
  500|       |
  501|      2|        curElem = curElem->fNext;
  502|      2|    }
  503|      4|    return 0;
  504|      8|}
_ZN11xercesc_3_214RefHashTableOfINS_12RangeFactoryENS_12StringHasherEE3putEPvPS1_:
  396|      4|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|      4|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|      4|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 4]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|      4|    XMLSize_t hashVal;
  406|      4|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|      4|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 4]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|      4|    else
  420|      4|    {
  421|      4|        newBucket =
  422|      4|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|      4|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|      4|        fBucketList[hashVal] = newBucket;
  425|      4|        fCount++;
  426|      4|    }
  427|      4|}
_ZN11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE3putEPvPS1_:
  396|    146|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|    146|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|    146|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 1, False: 145]
  ------------------
  402|      1|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|    146|    XMLSize_t hashVal;
  406|    146|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|    146|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 146]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|    146|    else
  420|    146|    {
  421|    146|        newBucket =
  422|    146|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|    146|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|    146|        fBucketList[hashVal] = newBucket;
  425|    146|        fCount++;
  426|    146|    }
  427|    146|}
_ZN11xercesc_3_214RefHashTableOfINS_17RangeTokenElemMapENS_12StringHasherEE6rehashEv:
  436|      1|{
  437|      1|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|      1|    RefHashTableBucketElem<TVal>** newBucketList =
  440|      1|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|      1|    (
  442|      1|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|      1|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|      1|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|      1|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|    110|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 109, False: 1]
  ------------------
  454|    109|    {
  455|       |        // Get the bucket list head for this entry
  456|    109|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|    190|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 81, False: 109]
  ------------------
  459|     81|        {
  460|       |            // Save the next element before we detach this one
  461|     81|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|     81|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|     81|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|     81|            curElem->fNext = newHeadElem;
  469|     81|            newBucketList[hashVal] = curElem;
  470|       |
  471|     81|            curElem = nextElem;
  472|     81|        }
  473|    109|    }
  474|       |
  475|      1|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|      1|    fBucketList = guard.release();
  480|      1|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|      1|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|      1|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEEC2EmbPNS_13MemoryManagerE:
   85|  17.0k|{
   86|  17.0k|    initialize(modulus);
   87|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE10initializeEm:
  109|  17.0k|{
  110|  17.0k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 17.0k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  17.0k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  17.0k|    (
  116|  17.0k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  17.0k|    );
  118|  1.87M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 1.85M, False: 17.0k]
  ------------------
  119|  1.85M|        fBucketList[index] = 0;
  120|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEED2Ev:
  124|  17.0k|{
  125|  17.0k|    cleanup();
  126|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE7cleanupEv:
  302|  17.0k|{
  303|  17.0k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  17.0k|    fMemoryManager->deallocate(fBucketList);
  307|  17.0k|    fBucketList = 0;
  308|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE9removeAllEv:
  203|  17.0k|{
  204|  17.0k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 0, False: 17.0k]
  ------------------
  205|      0|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|  1.87M|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 1.85M, False: 17.0k]
  ------------------
  209|  1.85M|    {
  210|       |        // Get the bucket list head for this entry
  211|  1.85M|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|  1.85M|        RefHashTableBucketElem<TVal>* nextElem;
  213|  1.92M|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 68.1k, False: 1.85M]
  ------------------
  214|  68.1k|        {
  215|       |            // Save the next element before we hose this one
  216|  68.1k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  68.1k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 0, False: 68.1k]
  ------------------
  223|      0|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  68.1k|            fMemoryManager->deallocate(curElem);
  230|  68.1k|            curElem = nextElem;
  231|  68.1k|        }
  232|       |
  233|       |        // Clean out this entry
  234|  1.85M|        fBucketList[buckInd] = 0;
  235|  1.85M|    }
  236|       |
  237|  17.0k|    fCount = 0;
  238|  17.0k|}
_ZNK11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE7isEmptyEv:
  134|  17.0k|{
  135|  17.0k|    return fCount==0;
  136|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_13XMLStringPool8PoolElemENS_12StringHasherEE3putEPvPS2_:
  396|  68.1k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  68.1k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  68.1k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 68.1k]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  68.1k|    XMLSize_t hashVal;
  406|  68.1k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  68.1k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 68.1k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  68.1k|    else
  420|  68.1k|    {
  421|  68.1k|        newBucket =
  422|  68.1k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  68.1k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  68.1k|        fBucketList[hashVal] = newBucket;
  425|  68.1k|        fCount++;
  426|  68.1k|    }
  427|  68.1k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   51|  8.51k|{
   52|  8.51k|    initialize(modulus);
   53|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE10initializeEm:
  109|  8.51k|{
  110|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 8.51k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  8.51k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  8.51k|    (
  116|  8.51k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  8.51k|    );
  118|   936k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 928k, False: 8.51k]
  ------------------
  119|   928k|        fBucketList[index] = 0;
  120|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE3getEPKv:
  349|  17.2k|{
  350|  17.2k|    XMLSize_t hashVal;
  351|  17.2k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  17.2k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 11.8k, False: 5.31k]
  ------------------
  353|  17.2k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE14findBucketElemEPKvRm:
  490|  22.5k|{
  491|       |    // Hash the key
  492|  22.5k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  22.5k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  28.5k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 17.9k, False: 10.6k]
  ------------------
  497|  17.9k|    {
  498|  17.9k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 11.8k, False: 6.05k]
  ------------------
  499|  11.8k|            return curElem;
  500|       |
  501|  6.05k|        curElem = curElem->fNext;
  502|  6.05k|    }
  503|  10.6k|    return 0;
  504|  22.5k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE3putEPvPS1_:
  396|  5.31k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  5.31k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  5.31k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 39, False: 5.27k]
  ------------------
  402|     39|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  5.31k|    XMLSize_t hashVal;
  406|  5.31k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  5.31k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 5.31k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  5.31k|    else
  420|  5.31k|    {
  421|  5.31k|        newBucket =
  422|  5.31k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  5.31k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  5.31k|        fBucketList[hashVal] = newBucket;
  425|  5.31k|        fCount++;
  426|  5.31k|    }
  427|  5.31k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLRefInfoENS_12StringHasherEE6rehashEv:
  436|     39|{
  437|     39|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|     39|    RefHashTableBucketElem<TVal>** newBucketList =
  440|     39|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|     39|    (
  442|     39|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|     39|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|     39|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|     39|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|  5.17k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 5.13k, False: 39]
  ------------------
  454|  5.13k|    {
  455|       |        // Get the bucket list head for this entry
  456|  5.13k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|  8.95k|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 3.82k, False: 5.13k]
  ------------------
  459|  3.82k|        {
  460|       |            // Save the next element before we detach this one
  461|  3.82k|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|  3.82k|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|  3.82k|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|  3.82k|            curElem->fNext = newHeadElem;
  469|  3.82k|            newBucketList[hashVal] = curElem;
  470|       |
  471|  3.82k|            curElem = nextElem;
  472|  3.82k|        }
  473|  5.13k|    }
  474|       |
  475|     39|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|     39|    fBucketList = guard.release();
  480|     39|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|     39|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|     39|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE9removeAllEv:
  203|  8.51k|{
  204|  8.51k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 8.16k, False: 351]
  ------------------
  205|  8.16k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|  46.3k|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 45.9k, False: 351]
  ------------------
  209|  45.9k|    {
  210|       |        // Get the bucket list head for this entry
  211|  45.9k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|  45.9k|        RefHashTableBucketElem<TVal>* nextElem;
  213|  46.6k|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 705, False: 45.9k]
  ------------------
  214|    705|        {
  215|       |            // Save the next element before we hose this one
  216|    705|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|    705|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 0, False: 705]
  ------------------
  223|      0|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|    705|            fMemoryManager->deallocate(curElem);
  230|    705|            curElem = nextElem;
  231|    705|        }
  232|       |
  233|       |        // Clean out this entry
  234|  45.9k|        fBucketList[buckInd] = 0;
  235|  45.9k|    }
  236|       |
  237|    351|    fCount = 0;
  238|    351|}
_ZNK11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE7isEmptyEv:
  134|  8.51k|{
  135|  8.51k|    return fCount==0;
  136|  8.51k|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_9DTDAttDefENS_12StringHasherEEC2EPNS_14RefHashTableOfIS1_S2_EEbPNS_13MemoryManagerE:
  535|  39.0k|{
  536|  39.0k|    if (!toEnum)
  ------------------
  |  Branch (536:9): [True: 0, False: 39.0k]
  ------------------
  537|      0|        ThrowXMLwithMemMgr(NullPointerException, XMLExcepts::CPtr_PointerIsZero, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  538|       |
  539|       |    //
  540|       |    //  Find the next available bucket element in the hash table. If it
  541|       |    //  comes back zero, that just means the table is empty.
  542|       |    //
  543|       |    //  Note that the -1 in the current hash tells it to start
  544|       |    //  from the beginning.
  545|       |    //
  546|  39.0k|    findNext();
  547|  39.0k|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_9DTDAttDefENS_12StringHasherEE8findNextEv:
  632|  39.0k|{
  633|       |    //
  634|       |    //  If there is a current element, move to its next element. If this
  635|       |    //  hits the end of the bucket, the next block will handle the rest.
  636|       |    //
  637|  39.0k|    if (fCurElem)
  ------------------
  |  Branch (637:9): [True: 0, False: 39.0k]
  ------------------
  638|      0|        fCurElem = fCurElem->fNext;
  639|       |
  640|       |    //
  641|       |    //  If the current element is null, then we have to move up to the
  642|       |    //  next hash value. If that is the hash modulus, then we cannot
  643|       |    //  go further.
  644|       |    //
  645|  39.0k|    if (!fCurElem)
  ------------------
  |  Branch (645:9): [True: 39.0k, False: 0]
  ------------------
  646|  39.0k|    {
  647|  39.0k|        fCurHash++;
  648|  39.0k|        if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (648:13): [True: 0, False: 39.0k]
  ------------------
  649|      0|            return;
  650|       |
  651|       |        // Else find the next non-empty bucket
  652|  1.11M|        while (fToEnum->fBucketList[fCurHash]==0)
  ------------------
  |  Branch (652:16): [True: 1.11M, False: 1.44k]
  ------------------
  653|  1.11M|        {
  654|       |            // Bump to the next hash value. If we max out return
  655|  1.11M|            fCurHash++;
  656|  1.11M|            if (fCurHash == fToEnum->fHashModulus)
  ------------------
  |  Branch (656:17): [True: 37.5k, False: 1.08M]
  ------------------
  657|  37.5k|                return;
  658|  1.11M|        }
  659|  1.44k|        fCurElem = fToEnum->fBucketList[fCurHash];
  660|  1.44k|    }
  661|  39.0k|}
_ZN11xercesc_3_224RefHashTableOfEnumeratorINS_9DTDAttDefENS_12StringHasherEED2Ev:
  551|  39.0k|{
  552|  39.0k|    if (fAdopted)
  ------------------
  |  Branch (552:9): [True: 0, False: 39.0k]
  ------------------
  553|      0|        delete fToEnum;
  554|  39.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEED2Ev:
  124|  39.0k|{
  125|  39.0k|    cleanup();
  126|  39.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE7cleanupEv:
  302|  39.0k|{
  303|  39.0k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  39.0k|    fMemoryManager->deallocate(fBucketList);
  307|  39.0k|    fBucketList = 0;
  308|  39.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE9removeAllEv:
  203|  39.0k|{
  204|  39.0k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 37.5k, False: 1.44k]
  ------------------
  205|  37.5k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|  53.1k|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 51.7k, False: 1.44k]
  ------------------
  209|  51.7k|    {
  210|       |        // Get the bucket list head for this entry
  211|  51.7k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|  51.7k|        RefHashTableBucketElem<TVal>* nextElem;
  213|  60.9k|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 9.22k, False: 51.7k]
  ------------------
  214|  9.22k|        {
  215|       |            // Save the next element before we hose this one
  216|  9.22k|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  9.22k|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 9.22k, False: 0]
  ------------------
  223|  9.22k|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  9.22k|            fMemoryManager->deallocate(curElem);
  230|  9.22k|            curElem = nextElem;
  231|  9.22k|        }
  232|       |
  233|       |        // Clean out this entry
  234|  51.7k|        fBucketList[buckInd] = 0;
  235|  51.7k|    }
  236|       |
  237|  1.44k|    fCount = 0;
  238|  1.44k|}
_ZNK11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE7isEmptyEv:
  134|   158k|{
  135|   158k|    return fCount==0;
  136|   158k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE3getEPKv:
  349|   105k|{
  350|   105k|    XMLSize_t hashVal;
  351|   105k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|   105k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 15.3k, False: 90.5k]
  ------------------
  353|   105k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE14findBucketElemEPKvRm:
  490|   115k|{
  491|       |    // Hash the key
  492|   115k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|   115k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|   126k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 26.8k, False: 99.7k]
  ------------------
  497|  26.8k|    {
  498|  26.8k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 15.3k, False: 11.4k]
  ------------------
  499|  15.3k|            return curElem;
  500|       |
  501|  11.4k|        curElem = curElem->fNext;
  502|  11.4k|    }
  503|  99.7k|    return 0;
  504|   115k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEEC2EmbPNS_13MemoryManagerE:
   85|  39.0k|{
   86|  39.0k|    initialize(modulus);
   87|  39.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE10initializeEm:
  109|  39.0k|{
  110|  39.0k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 39.0k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  39.0k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  39.0k|    (
  116|  39.0k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  39.0k|    );
  118|  1.17M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 1.13M, False: 39.0k]
  ------------------
  119|  1.13M|        fBucketList[index] = 0;
  120|  39.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE3putEPvPS1_:
  396|  9.22k|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  9.22k|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  9.22k|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 198, False: 9.02k]
  ------------------
  402|    198|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  9.22k|    XMLSize_t hashVal;
  406|  9.22k|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  9.22k|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 9.22k]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  9.22k|    else
  420|  9.22k|    {
  421|  9.22k|        newBucket =
  422|  9.22k|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  9.22k|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  9.22k|        fBucketList[hashVal] = newBucket;
  425|  9.22k|        fCount++;
  426|  9.22k|    }
  427|  9.22k|}
_ZN11xercesc_3_214RefHashTableOfINS_9DTDAttDefENS_12StringHasherEE6rehashEv:
  436|    198|{
  437|    198|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|    198|    RefHashTableBucketElem<TVal>** newBucketList =
  440|    198|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|    198|    (
  442|    198|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|    198|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|    198|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|    198|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|  9.84k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 9.64k, False: 198]
  ------------------
  454|  9.64k|    {
  455|       |        // Get the bucket list head for this entry
  456|  9.64k|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|  16.7k|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 7.12k, False: 9.64k]
  ------------------
  459|  7.12k|        {
  460|       |            // Save the next element before we detach this one
  461|  7.12k|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|  7.12k|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|  7.12k|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|  7.12k|            curElem->fNext = newHeadElem;
  469|  7.12k|            newBucketList[hashVal] = curElem;
  470|       |
  471|  7.12k|            curElem = nextElem;
  472|  7.12k|        }
  473|  9.64k|    }
  474|       |
  475|    198|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|    198|    fBucketList = guard.release();
  480|    198|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|    198|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|    198|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEEC2EmbPNS_13MemoryManagerE:
   85|  1.09k|{
   86|  1.09k|    initialize(modulus);
   87|  1.09k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE10initializeEm:
  109|  1.09k|{
  110|  1.09k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 1.09k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  1.09k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  1.09k|    (
  116|  1.09k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  1.09k|    );
  118|  5.29M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 5.29M, False: 1.09k]
  ------------------
  119|  5.29M|        fBucketList[index] = 0;
  120|  1.09k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE3getEPKv:
  349|  68.1M|{
  350|  68.1M|    XMLSize_t hashVal;
  351|  68.1M|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|  68.1M|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 63.8M, False: 4.31M]
  ------------------
  353|  68.1M|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE14findBucketElemEPKvRm:
  490|  72.4M|{
  491|       |    // Hash the key
  492|  72.4M|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|  72.4M|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|  91.7M|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 83.0M, False: 8.62M]
  ------------------
  497|  83.0M|    {
  498|  83.0M|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 63.8M, False: 19.2M]
  ------------------
  499|  63.8M|            return curElem;
  500|       |
  501|  19.2M|        curElem = curElem->fNext;
  502|  19.2M|    }
  503|  8.62M|    return 0;
  504|  72.4M|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE3putEPvPS1_:
  396|  4.31M|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|  4.31M|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|  4.31M|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 185, False: 4.31M]
  ------------------
  402|    185|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|  4.31M|    XMLSize_t hashVal;
  406|  4.31M|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|  4.31M|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 4.31M]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|  4.31M|    else
  420|  4.31M|    {
  421|  4.31M|        newBucket =
  422|  4.31M|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|  4.31M|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|  4.31M|        fBucketList[hashVal] = newBucket;
  425|  4.31M|        fCount++;
  426|  4.31M|    }
  427|  4.31M|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE6rehashEv:
  436|    185|{
  437|    185|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  438|       |
  439|    185|    RefHashTableBucketElem<TVal>** newBucketList =
  440|    185|        (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  441|    185|    (
  442|    185|        newMod * sizeof(RefHashTableBucketElem<TVal>*)
  443|    185|    );
  444|       |
  445|       |    // Make sure the new bucket list is destroyed if an
  446|       |    // exception is thrown.
  447|    185|    ArrayJanitor<RefHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  448|       |
  449|    185|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  450|       |
  451|       |
  452|       |    // Rehash all existing entries.
  453|  6.74M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (453:31): [True: 6.74M, False: 185]
  ------------------
  454|  6.74M|    {
  455|       |        // Get the bucket list head for this entry
  456|  6.74M|        RefHashTableBucketElem<TVal>* curElem = fBucketList[index];
  457|       |
  458|  11.8M|        while (curElem)
  ------------------
  |  Branch (458:16): [True: 5.06M, False: 6.74M]
  ------------------
  459|  5.06M|        {
  460|       |            // Save the next element before we detach this one
  461|  5.06M|            RefHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  462|       |
  463|  5.06M|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  464|       |
  465|  5.06M|            RefHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  466|       |
  467|       |            // Insert at the start of this bucket's list.
  468|  5.06M|            curElem->fNext = newHeadElem;
  469|  5.06M|            newBucketList[hashVal] = curElem;
  470|       |
  471|  5.06M|            curElem = nextElem;
  472|  5.06M|        }
  473|  6.74M|    }
  474|       |
  475|    185|    RefHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  476|       |
  477|       |    // Everything is OK at this point, so update the
  478|       |    // member variables.
  479|    185|    fBucketList = guard.release();
  480|    185|    fHashModulus = newMod;
  481|       |
  482|       |    // Delete the old bucket list.
  483|    185|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  484|       |
  485|    185|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEED2Ev:
  124|  1.09k|{
  125|  1.09k|    cleanup();
  126|  1.09k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE7cleanupEv:
  302|  1.09k|{
  303|  1.09k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  1.09k|    fMemoryManager->deallocate(fBucketList);
  307|  1.09k|    fBucketList = 0;
  308|  1.09k|}
_ZN11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE9removeAllEv:
  203|  1.09k|{
  204|  1.09k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 0, False: 1.09k]
  ------------------
  205|      0|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|  12.0M|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 12.0M, False: 1.09k]
  ------------------
  209|  12.0M|    {
  210|       |        // Get the bucket list head for this entry
  211|  12.0M|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|  12.0M|        RefHashTableBucketElem<TVal>* nextElem;
  213|  16.3M|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 4.31M, False: 12.0M]
  ------------------
  214|  4.31M|        {
  215|       |            // Save the next element before we hose this one
  216|  4.31M|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|  4.31M|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 4.31M, False: 0]
  ------------------
  223|  4.31M|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|  4.31M|            fMemoryManager->deallocate(curElem);
  230|  4.31M|            curElem = nextElem;
  231|  4.31M|        }
  232|       |
  233|       |        // Clean out this entry
  234|  12.0M|        fBucketList[buckInd] = 0;
  235|  12.0M|    }
  236|       |
  237|  1.09k|    fCount = 0;
  238|  1.09k|}
_ZNK11xercesc_3_214RefHashTableOfINS_10XMLIntegerENS_16CMStateSetHasherEE7isEmptyEv:
  134|  1.09k|{
  135|  1.09k|    return fCount==0;
  136|  1.09k|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE3getEPKv:
  349|   253k|{
  350|   253k|    XMLSize_t hashVal;
  351|   253k|    RefHashTableBucketElem<TVal>* findIt = findBucketElem(key, hashVal);
  352|   253k|    return findIt ? findIt->fData : 0;
  ------------------
  |  Branch (352:12): [True: 129k, False: 123k]
  ------------------
  353|   253k|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE14findBucketElemEPKvRm:
  490|   253k|{
  491|       |    // Hash the key
  492|   253k|    hashVal = fHasher.getHashVal(key, fHashModulus);
  493|       |
  494|       |    // Search that bucket for the key
  495|   253k|    RefHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  496|   265k|    while (curElem)
  ------------------
  |  Branch (496:12): [True: 140k, False: 124k]
  ------------------
  497|   140k|    {
  498|   140k|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (498:13): [True: 129k, False: 11.3k]
  ------------------
  499|   129k|            return curElem;
  500|       |
  501|  11.3k|        curElem = curElem->fNext;
  502|  11.3k|    }
  503|   124k|    return 0;
  504|   253k|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE3putEPvPj:
  396|    705|{
  397|       |    // Apply 0.75 load factor to find threshold.
  398|    705|    XMLSize_t threshold = fHashModulus * 3 / 4;
  399|       |
  400|       |    // If we've grown too big, expand the table and rehash.
  401|    705|    if (fCount >= threshold)
  ------------------
  |  Branch (401:9): [True: 0, False: 705]
  ------------------
  402|      0|        rehash();
  403|       |
  404|       |    // First see if the key exists already
  405|    705|    XMLSize_t hashVal;
  406|    705|    RefHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  407|       |
  408|       |    //
  409|       |    //  If so,then update its value. If not, then we need to add it to
  410|       |    //  the right bucket
  411|       |    //
  412|    705|    if (newBucket)
  ------------------
  |  Branch (412:9): [True: 0, False: 705]
  ------------------
  413|      0|    {
  414|      0|        if (fAdoptedElems)
  ------------------
  |  Branch (414:13): [True: 0, False: 0]
  ------------------
  415|      0|            delete newBucket->fData;
  416|      0|        newBucket->fData = valueToAdopt;
  417|      0|        newBucket->fKey = key;
  418|      0|    }
  419|    705|    else
  420|    705|    {
  421|    705|        newBucket =
  422|    705|             new (fMemoryManager->allocate(sizeof(RefHashTableBucketElem<TVal>)))
  423|    705|             RefHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  424|    705|        fBucketList[hashVal] = newBucket;
  425|    705|        fCount++;
  426|    705|    }
  427|    705|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEEC2EmbPNS_13MemoryManagerE:
   85|  8.51k|{
   86|  8.51k|    initialize(modulus);
   87|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE10initializeEm:
  109|  8.51k|{
  110|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 8.51k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  8.51k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  8.51k|    (
  116|  8.51k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  8.51k|    );
  118|  1.12M|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 1.11M, False: 8.51k]
  ------------------
  119|  1.11M|        fBucketList[index] = 0;
  120|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEED2Ev:
  124|  8.51k|{
  125|  8.51k|    cleanup();
  126|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfIjNS_9PtrHasherEE7cleanupEv:
  302|  8.51k|{
  303|  8.51k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  8.51k|    fMemoryManager->deallocate(fBucketList);
  307|  8.51k|    fBucketList = 0;
  308|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10ValueStoreENS_9PtrHasherEE9removeAllEv:
  203|  17.0k|{
  204|  17.0k|    if(isEmpty())
  ------------------
  |  Branch (204:8): [True: 17.0k, False: 0]
  ------------------
  205|  17.0k|        return;
  206|       |
  207|       |    // Clean up the buckets first
  208|      0|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (208:33): [True: 0, False: 0]
  ------------------
  209|      0|    {
  210|       |        // Get the bucket list head for this entry
  211|      0|        RefHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  212|      0|        RefHashTableBucketElem<TVal>* nextElem;
  213|      0|        while (curElem)
  ------------------
  |  Branch (213:16): [True: 0, False: 0]
  ------------------
  214|      0|        {
  215|       |            // Save the next element before we hose this one
  216|      0|            nextElem = curElem->fNext;
  217|       |
  218|       |            // If we adopted the data, then delete it too
  219|       |            //    (Note:  the userdata hash table instance has data type of void *.
  220|       |            //    This will generate compiler warnings here on some platforms, but they
  221|       |            //    can be ignored since fAdoptedElements is false.
  222|      0|            if (fAdoptedElems)
  ------------------
  |  Branch (222:17): [True: 0, False: 0]
  ------------------
  223|      0|                delete curElem->fData;
  224|       |
  225|       |            // Then delete the current element and move forward
  226|       |             // delete curElem;
  227|       |            // destructor doesn't do anything...
  228|       |            // curElem->~RefHashTableBucketElem();
  229|      0|            fMemoryManager->deallocate(curElem);
  230|      0|            curElem = nextElem;
  231|      0|        }
  232|       |
  233|       |        // Clean out this entry
  234|      0|        fBucketList[buckInd] = 0;
  235|      0|    }
  236|       |
  237|      0|    fCount = 0;
  238|      0|}
_ZNK11xercesc_3_214RefHashTableOfINS_10ValueStoreENS_9PtrHasherEE7isEmptyEv:
  134|  17.0k|{
  135|  17.0k|    return fCount==0;
  136|  17.0k|}
_ZN11xercesc_3_214RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEC2EmbPNS_13MemoryManagerE:
   85|  8.51k|{
   86|  8.51k|    initialize(modulus);
   87|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10ValueStoreENS_9PtrHasherEE10initializeEm:
  109|  8.51k|{
  110|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (110:9): [True: 0, False: 8.51k]
  ------------------
  111|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  112|       |
  113|       |    // Allocate the bucket list and zero them
  114|  8.51k|    fBucketList = (RefHashTableBucketElem<TVal>**) fMemoryManager->allocate
  115|  8.51k|    (
  116|  8.51k|        fHashModulus * sizeof(RefHashTableBucketElem<TVal>*)
  117|  8.51k|    );
  118|   119k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (118:31): [True: 110k, False: 8.51k]
  ------------------
  119|   110k|        fBucketList[index] = 0;
  120|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10ValueStoreENS_9PtrHasherEED2Ev:
  124|  8.51k|{
  125|  8.51k|    cleanup();
  126|  8.51k|}
_ZN11xercesc_3_214RefHashTableOfINS_10ValueStoreENS_9PtrHasherEE7cleanupEv:
  302|  8.51k|{
  303|  8.51k|    removeAll();
  304|       |
  305|       |    // Then delete the bucket list & hasher
  306|  8.51k|    fMemoryManager->deallocate(fBucketList);
  307|  8.51k|    fBucketList = 0;
  308|  8.51k|}

_ZN11xercesc_3_222RefHashTableBucketElemINS_8ENameMapEEC2EPvPS1_PS2_:
   48|     48|  {
   49|     48|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_12KVStringPairEEC2EPvPS1_PS2_:
   48|     26|  {
   49|     26|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_7GrammarEEC2EPvPS1_PS2_:
   48|  8.51k|  {
   49|  8.51k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_17DatatypeValidatorEEC2EPvPS1_PS2_:
   48|     45|  {
   49|     45|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_14XMLCanRepGroupEEC2EPvPS1_PS2_:
   48|     14|  {
   49|     14|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_15XMLNotationDeclEEC2EPvPS1_PS2_:
   48|  1.86k|  {
   49|  1.86k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_13DTDEntityDeclEEC2EPvPS1_PS2_:
   48|  2.89k|  {
   49|  2.89k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_14DTDElementDeclEEC2EPvPS1_PS2_:
   48|  52.6k|  {
   49|  52.6k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_12RangeFactoryEEC2EPvPS1_PS2_:
   48|      4|  {
   49|      4|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_17RangeTokenElemMapEEC2EPvPS1_PS2_:
   48|    146|  {
   49|    146|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_13XMLStringPool8PoolElemEEC2EPvPS2_PS3_:
   48|  68.1k|  {
   49|  68.1k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_10XMLRefInfoEEC2EPvPS1_PS2_:
   48|  5.31k|  {
   49|  5.31k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_9DTDAttDefEEC2EPvPS1_PS2_:
   48|  9.22k|  {
   49|  9.22k|  }
_ZN11xercesc_3_222RefHashTableBucketElemINS_10XMLIntegerEEC2EPvPS1_PS2_:
   48|  4.31M|  {
   49|  4.31M|  }
_ZN11xercesc_3_222RefHashTableBucketElemIjEC2EPvPjPS1_:
   48|    705|  {
   49|    705|  }

_ZN11xercesc_3_210RefStackOfINS_9XMLReaderEED2Ev:
   45|  8.51k|{
   46|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_13XMLEntityDeclEED2Ev:
   45|  8.51k|{
   46|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_9XMLReaderEE5emptyEv:
  103|  24.8k|{
  104|  24.8k|    return (fVector.size() == 0);
  105|  24.8k|}
_ZN11xercesc_3_210RefStackOfINS_9XMLReaderEE3popEv:
   84|  16.8k|{
   85|  16.8k|    const XMLSize_t curSize = fVector.size();
   86|  16.8k|    if (curSize == 0)
  ------------------
  |  Branch (86:9): [True: 0, False: 16.8k]
  ------------------
   87|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   88|       |
   89|       |    // Orphan off the element from the last slot in the vector
   90|  16.8k|    return fVector.orphanElementAt(curSize-1);
   91|  16.8k|}
_ZN11xercesc_3_210RefStackOfINS_13XMLEntityDeclEE3popEv:
   84|  16.8k|{
   85|  16.8k|    const XMLSize_t curSize = fVector.size();
   86|  16.8k|    if (curSize == 0)
  ------------------
  |  Branch (86:9): [True: 0, False: 16.8k]
  ------------------
   87|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   88|       |
   89|       |    // Orphan off the element from the last slot in the vector
   90|  16.8k|    return fVector.orphanElementAt(curSize-1);
   91|  16.8k|}
_ZN11xercesc_3_210RefStackOfINS_13XMLEntityDeclEE4sizeEv:
  113|  19.5k|{
  114|  19.5k|    return fVector.size();
  115|  19.5k|}
_ZNK11xercesc_3_210RefStackOfINS_13XMLEntityDeclEE9elementAtEm:
   54|  13.7k|{
   55|  13.7k|    if (index >= fVector.size())
  ------------------
  |  Branch (55:9): [True: 0, False: 13.7k]
  ------------------
   56|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Stack_BadIndex, fVector.getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   57|  13.7k|    return fVector.elementAt(index);
   58|  13.7k|}
_ZN11xercesc_3_210RefStackOfINS_9XMLReaderEEC2EmbPNS_13MemoryManagerE:
   41|  8.51k|{
   42|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_13XMLEntityDeclEEC2EmbPNS_13MemoryManagerE:
   41|  8.51k|{
   42|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_9XMLReaderEE4pushEPS1_:
   70|  16.8k|{
   71|  16.8k|    fVector.addElement(toPush);
   72|  16.8k|}
_ZN11xercesc_3_210RefStackOfINS_13XMLEntityDeclEE4pushEPS1_:
   70|  16.8k|{
   71|  16.8k|    fVector.addElement(toPush);
   72|  16.8k|}
_ZN11xercesc_3_210RefStackOfINS_9XMLReaderEE17removeAllElementsEv:
   94|  8.51k|{
   95|  8.51k|    fVector.removeAllElements();
   96|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_13XMLEntityDeclEE17removeAllElementsEv:
   94|  8.51k|{
   95|  8.51k|    fVector.removeAllElements();
   96|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEE17removeAllElementsEv:
   94|  8.51k|{
   95|  8.51k|    fVector.removeAllElements();
   96|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEED2Ev:
   45|  8.51k|{
   46|  8.51k|}
_ZN11xercesc_3_210RefStackOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEEC2EmbPNS_13MemoryManagerE:
   41|  8.51k|{
   42|  8.51k|}

_ZN11xercesc_3_211RefVectorOfINS_8ENameMapEEC2EmbPNS_13MemoryManagerE:
   40|      1|{
   41|      1|}
_ZN11xercesc_3_211RefVectorOfINS_23DOMImplementationSourceEEC2EmbPNS_13MemoryManagerE:
   40|      1|{
   41|      1|}
_ZN11xercesc_3_211RefVectorOfINS_7XMLAttrEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_7XMLAttrEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 8.51k, False: 0]
  ------------------
   46|  8.51k|    {
   47|  11.6k|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 3.11k, False: 8.51k]
  ------------------
   48|  3.11k|            delete this->fElemList[index];
   49|  8.51k|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_9XMLReaderEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 8.51k, False: 0]
  ------------------
   46|  8.51k|    {
   47|  8.51k|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 8.51k]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|  8.51k|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_13XMLEntityDeclEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 0, False: 8.51k]
  ------------------
   46|      0|    {
   47|      0|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 0]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|      0|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_9XMLReaderEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_13XMLEntityDeclEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_5TokenEEC2EmbPNS_13MemoryManagerE:
   40|     11|{
   41|     11|}
_ZN11xercesc_3_211RefVectorOfINS_2OpEEC2EmbPNS_13MemoryManagerE:
   40|      5|{
   41|      5|}
_ZN11xercesc_3_211RefVectorOfINS_20PSVIAttributeStorageEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_20PSVIAttributeStorageEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 8.51k, False: 0]
  ------------------
   46|  8.51k|    {
   47|  8.51k|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 8.51k]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|  8.51k|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_12KVStringPairEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_12KVStringPairEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 8.51k, False: 0]
  ------------------
   46|  8.51k|    {
   47|  8.51k|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 8.51k]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|  8.51k|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 8.51k, False: 0]
  ------------------
   46|  8.51k|    {
   47|  8.51k|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 8.51k]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|  8.51k|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_10ValueStoreEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_10ValueStoreEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 0, False: 8.51k]
  ------------------
   46|      0|    {
   47|      0|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 0]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|      0|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_14RefHashTableOfINS_10ValueStoreENS_9PtrHasherEEEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_12XPathMatcherEEC2EmbPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|}
_ZN11xercesc_3_211RefVectorOfINS_12XPathMatcherEED2Ev:
   44|  8.51k|{
   45|  8.51k|    if (this->fAdoptedElems)
  ------------------
  |  Branch (45:9): [True: 8.51k, False: 0]
  ------------------
   46|  8.51k|    {
   47|  8.51k|        for (XMLSize_t index = 0; index < this->fCurCount; index++)
  ------------------
  |  Branch (47:35): [True: 0, False: 8.51k]
  ------------------
   48|      0|            delete this->fElemList[index];
   49|  8.51k|    }
   50|  8.51k|    this->fMemoryManager->deallocate(this->fElemList);//delete [] this->fElemList;
   51|  8.51k|}

_ZN11xercesc_3_213XMLStringPoolC2EjPNS_13MemoryManagerE:
   42|  17.0k|{
   43|       |    // Create the hash table, passing it the modulus
   44|  17.0k|    fHashTable = new (fMemoryManager) RefHashTableOf<PoolElem>(modulus, false, fMemoryManager);
   45|       |
   46|       |    // Do an initial allocation of the id map and zero it all out
   47|  17.0k|    fIdMap = (PoolElem**) fMemoryManager->allocate
   48|  17.0k|    (
   49|  17.0k|        fMapCapacity * sizeof(PoolElem*)
   50|  17.0k|    ); //new PoolElem*[fMapCapacity];
   51|  17.0k|    memset(fIdMap, 0, sizeof(PoolElem*) * fMapCapacity);
   52|  17.0k|}
_ZN11xercesc_3_213XMLStringPoolD2Ev:
   55|  17.0k|{
   56|       |    // delete all buckelements, since the hashtable doesn't adopt the elements anymore
   57|  85.1k|    for (unsigned int index = 1; index < fCurId; index++)
  ------------------
  |  Branch (57:34): [True: 68.1k, False: 17.0k]
  ------------------
   58|  68.1k|    {
   59|       |        //fIdMap[index]->~PoolElem();                                // we have no destructor
   60|  68.1k|        fMemoryManager->deallocate((void*) fIdMap[index]->fString);  // deallocate memory
   61|  68.1k|        fMemoryManager->deallocate(fIdMap[index]);                   // deallocate memory
   62|  68.1k|    }
   63|  17.0k|    delete fHashTable;
   64|  17.0k|    fMemoryManager->deallocate(fIdMap); //delete [] fIdMap;
   65|  17.0k|}
_ZN11xercesc_3_213XMLStringPool11addNewEntryEPKDs:
   87|  68.1k|{
   88|       |    // See if we need to expand the id map
   89|  68.1k|    if (fCurId == fMapCapacity)
  ------------------
  |  Branch (89:9): [True: 0, False: 68.1k]
  ------------------
   90|      0|    {
   91|       |        // Calculate the new capacity, create a temp new map, and zero it
   92|      0|        const unsigned int newCap = (unsigned int)(fMapCapacity * 1.5);
   93|      0|        PoolElem** newMap = (PoolElem**) fMemoryManager->allocate
   94|      0|        (
   95|      0|            newCap * sizeof(PoolElem*)
   96|      0|        ); //new PoolElem*[newCap];
   97|      0|        memset(newMap, 0, sizeof(PoolElem*) * newCap);
   98|       |
   99|       |        //
  100|       |        //  Copy over the old elements from the old map. They are just pointers
  101|       |        //  so we can do it all at once.
  102|       |        //
  103|      0|        memcpy(newMap, fIdMap, sizeof(PoolElem*) * fMapCapacity);
  104|       |
  105|       |        // Clean up the old map and store the new info
  106|      0|        fMemoryManager->deallocate(fIdMap); //delete [] fIdMap;
  107|      0|        fIdMap = newMap;
  108|      0|        fMapCapacity = newCap;
  109|      0|    }
  110|       |
  111|       |    //
  112|       |    //  Ok, now create a new element and add it to the hash table. Then store
  113|       |    //  this new element in the id map at the current id index, then bump the
  114|       |    //  id index.
  115|       |    //
  116|  68.1k|    PoolElem* newElem = (PoolElem*) fMemoryManager->allocate(sizeof(PoolElem));
  117|  68.1k|    newElem->fId      = fCurId;
  118|  68.1k|    newElem->fString  = XMLString::replicate(newString, fMemoryManager);
  119|  68.1k|    fHashTable->put((void*)newElem->fString, newElem);
  120|  68.1k|    fIdMap[fCurId] = newElem;
  121|       |
  122|       |    // Bump the current id and return the id of the new elem we just added
  123|  68.1k|    fCurId++;
  124|  68.1k|    return newElem->fId;
  125|  68.1k|}

_ZN11xercesc_3_213XMLStringPool9addOrFindEPKDs:
  131|  68.1k|{
  132|  68.1k|    PoolElem* elemToFind = fHashTable->get(newString);
  133|  68.1k|    if (elemToFind)
  ------------------
  |  Branch (133:9): [True: 0, False: 68.1k]
  ------------------
  134|      0|        return elemToFind->fId;
  135|       |
  136|  68.1k|    return addNewEntry(newString);
  137|  68.1k|}
_ZNK11xercesc_3_213XMLStringPool5getIdEPKDs:
  140|    146|{
  141|    146|    PoolElem* elemToFind = fHashTable->get(toFind);
  142|    146|    if (elemToFind)
  ------------------
  |  Branch (142:9): [True: 146, False: 0]
  ------------------
  143|    146|        return elemToFind->fId;
  144|       |
  145|       |    // Not found, so return zero, which is never a legal id
  146|      0|    return 0;
  147|    146|}

_ZN11xercesc_3_211ENameMapForINS_15XMLChTranscoderEEC2EPKDs:
   35|      2|{
   36|      2|}
_ZNK11xercesc_3_211ENameMapForINS_15XMLChTranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|  16.8k|{
   50|  16.8k|    return new (manager) TType(getKey(), blockSize, manager);
   51|  16.8k|}
_ZN11xercesc_3_211ENameMapForINS_18XMLASCIITranscoderEEC2EPKDs:
   35|      5|{
   36|      5|}
_ZNK11xercesc_3_211ENameMapForINS_18XMLASCIITranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|     76|{
   50|     76|    return new (manager) TType(getKey(), blockSize, manager);
   51|     76|}
_ZN11xercesc_3_211ENameMapForINS_17XMLUTF8TranscoderEEC2EPKDs:
   35|      3|{
   36|      3|}
_ZNK11xercesc_3_211ENameMapForINS_17XMLUTF8TranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|    964|{
   50|    964|    return new (manager) TType(getKey(), blockSize, manager);
   51|    964|}
_ZN11xercesc_3_211ENameMapForINS_18XML88591TranscoderEEC2EPKDs:
   35|     12|{
   36|     12|}
_ZNK11xercesc_3_211ENameMapForINS_18XML88591TranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|     68|{
   50|     68|    return new (manager) TType(getKey(), blockSize, manager);
   51|     68|}
_ZN11xercesc_3_217EEndianNameMapForINS_18XMLUTF16TranscoderEEC2EPKDsb:
   63|     13|{
   64|     13|}
_ZNK11xercesc_3_217EEndianNameMapForINS_18XMLUTF16TranscoderEE7makeNewEmPNS_13MemoryManagerE:
   77|     25|{
   78|     25|    return new (manager) TType(getKey(), blockSize, fSwapped, manager);
   79|     25|}
_ZN11xercesc_3_217EEndianNameMapForINS_17XMLUCS4TranscoderEEC2EPKDsb:
   63|     11|{
   64|     11|}
_ZN11xercesc_3_211ENameMapForINS_19XMLEBCDICTranscoderEEC2EPKDs:
   35|      3|{
   36|      3|}
_ZNK11xercesc_3_211ENameMapForINS_19XMLEBCDICTranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|     10|{
   50|     10|    return new (manager) TType(getKey(), blockSize, manager);
   51|     10|}
_ZN11xercesc_3_211ENameMapForINS_20XMLIBM1047TranscoderEEC2EPKDs:
   35|      2|{
   36|      2|}
_ZNK11xercesc_3_211ENameMapForINS_20XMLIBM1047TranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|      1|{
   50|      1|    return new (manager) TType(getKey(), blockSize, manager);
   51|      1|}
_ZN11xercesc_3_211ENameMapForINS_20XMLIBM1140TranscoderEEC2EPKDs:
   35|      4|{
   36|      4|}
_ZNK11xercesc_3_211ENameMapForINS_20XMLIBM1140TranscoderEE7makeNewEmPNS_13MemoryManagerE:
   49|      9|{
   50|      9|    return new (manager) TType(getKey(), blockSize, manager);
   51|      9|}
_ZN11xercesc_3_211ENameMapForINS_20XMLWin1252TranscoderEEC2EPKDs:
   35|      1|{
   36|      1|}

_ZN11xercesc_3_28ENameMapC2EPKDs:
   74|     56|    {
   75|     56|    }
_ZNK11xercesc_3_28ENameMap6getKeyEv:
   63|  18.0k|    {
   64|  18.0k|        return fEncodingName;
   65|  18.0k|    }

_ZN11xercesc_3_214XMLInitializer22initializeTransServiceEv:
   58|      1|{
   59|      1|    XMLTransService::gMappings = new RefHashTableOf<ENameMap>(103);
   60|      1|    XMLTransService::gMappingsRecognizer = new RefVectorOf<ENameMap>(
   61|      1|      (XMLSize_t)XMLRecognizer::Encodings_Count);
   62|      1|}
_ZN11xercesc_3_215XMLTransServiceC2Ev:
   77|      1|{
   78|      1|}
_ZN11xercesc_3_215XMLTransService20makeNewTranscoderForEPKDsRNS0_5CodesEmPNS_13MemoryManagerE:
  114|  8.31k|{
  115|       |    //
  116|       |    // If strict IANA encoding flag is set, validate encoding name
  117|       |    //
  118|  8.31k|    if (gStrictIANAEncoding)
  ------------------
  |  Branch (118:9): [True: 0, False: 8.31k]
  ------------------
  119|      0|    {
  120|      0|        if (!EncodingValidator::instance()->isValidEncoding(encodingName))
  ------------------
  |  Branch (120:13): [True: 0, False: 0]
  ------------------
  121|      0|        {
  122|      0|            resValue = XMLTransService::UnsupportedEncoding;
  123|      0|            return 0;
  124|      0|        }
  125|      0|    }
  126|       |
  127|       |    //
  128|       |    //  First try to find it in our list of mappings to intrinsically
  129|       |    //  supported encodings. We have to upper case the passed encoding
  130|       |    //  name because we use a hash table and we stored all our mappings
  131|       |    //  in all uppercase.
  132|       |    //
  133|  8.31k|    const XMLSize_t bufSize = 2048;
  134|  8.31k|    XMLCh upBuf[bufSize + 1];
  135|  8.31k|    if (!XMLString::copyNString(upBuf, encodingName, bufSize))
  ------------------
  |  Branch (135:9): [True: 16, False: 8.30k]
  ------------------
  136|     16|    {
  137|     16|        resValue = XMLTransService::InternalFailure;
  138|     16|        return 0;
  139|     16|    }
  140|  8.30k|    XMLString::upperCaseASCII(upBuf);
  141|  8.30k|    ENameMap* ourMapping = gMappings->get(upBuf);
  142|       |
  143|       |    // If we found it, then call the factory method for it
  144|  8.30k|    if (ourMapping)
  ------------------
  |  Branch (144:9): [True: 969, False: 7.33k]
  ------------------
  145|    969|    {
  146|    969|       XMLTranscoder* temp = ourMapping->makeNew(blockSize, manager);
  147|    969|       resValue = temp ? XMLTransService::Ok : XMLTransService::InternalFailure;
  ------------------
  |  Branch (147:19): [True: 969, False: 0]
  ------------------
  148|    969|       return temp;
  149|    969|    }
  150|       |
  151|       |    //
  152|       |    //  It wasn't an intrinsic and it wasn't disallowed, so pass it on
  153|       |    //  to the trans service to see if he can make anything of it.
  154|       |    //
  155|       |
  156|  7.33k|    XMLTranscoder* temp =  makeNewXMLTranscoder(encodingName, resValue, blockSize, manager);
  157|       |
  158|       |    // if successful, set resValue to OK
  159|       |    // if failed, the makeNewXMLTranscoder has already set the proper failing resValue
  160|  7.33k|    if (temp) resValue =  XMLTransService::Ok;
  ------------------
  |  Branch (160:9): [True: 7.25k, False: 78]
  ------------------
  161|       |
  162|  7.33k|    return temp;
  163|       |
  164|  8.30k|}
_ZN11xercesc_3_215XMLTransService20makeNewTranscoderForENS_13XMLRecognizer9EncodingsERNS0_5CodesEmPNS_13MemoryManagerE:
  172|  17.0k|{
  173|       |    //
  174|       |    // We can only make transcoder if the passed encodingEnum is under this range
  175|       |    //
  176|  17.0k|    if (encodingEnum < XMLRecognizer::Encodings_Min || encodingEnum > XMLRecognizer::Encodings_Max) {
  ------------------
  |  Branch (176:9): [True: 0, False: 17.0k]
  |  Branch (176:56): [True: 0, False: 17.0k]
  ------------------
  177|      0|        resValue = XMLTransService::InternalFailure;
  178|      0|        return 0;
  179|      0|    }
  180|       |
  181|  17.0k|    ENameMap* ourMapping = gMappingsRecognizer->elementAt(encodingEnum);
  182|       |
  183|       |    // If we found it, then call the factory method for it
  184|  17.0k|    if (ourMapping)    {
  ------------------
  |  Branch (184:9): [True: 17.0k, False: 0]
  ------------------
  185|  17.0k|       XMLTranscoder* temp = ourMapping->makeNew(blockSize, manager);
  186|  17.0k|       resValue = temp ? XMLTransService::Ok : XMLTransService::InternalFailure;
  ------------------
  |  Branch (186:19): [True: 17.0k, False: 0]
  ------------------
  187|  17.0k|       return temp;
  188|  17.0k|    }
  189|      0|    else {
  190|      0|        XMLTranscoder* temp =  makeNewXMLTranscoder(XMLRecognizer::nameForEncoding(encodingEnum, manager), resValue, blockSize, manager);
  191|       |
  192|       |        // if successful, set resValue to OK
  193|       |        // if failed, the makeNewXMLTranscoder has already set the proper failing resValue
  194|      0|        if (temp) resValue =  XMLTransService::Ok;
  ------------------
  |  Branch (194:13): [True: 0, False: 0]
  ------------------
  195|       |
  196|      0|        return temp;
  197|      0|    }
  198|       |
  199|  17.0k|}
_ZN11xercesc_3_215XMLTransService16initTransServiceEv:
  208|      1|{
  209|       |    //
  210|       |    //  A stupid way to increment the fCurCount inside the RefVectorOf
  211|       |    //
  212|      9|    for (XMLSize_t i = 0; i < (XMLSize_t)XMLRecognizer::Encodings_Count; i++)
  ------------------
  |  Branch (212:27): [True: 8, False: 1]
  ------------------
  213|      8|        gMappingsRecognizer->addElement(0);
  214|       |
  215|       |    //
  216|       |    //  Add in the magical mapping for the native XMLCh transcoder. This
  217|       |    //  is used for internal entities.
  218|       |    //
  219|      1|    gMappingsRecognizer->setElementAt(new ENameMapFor<XMLChTranscoder>(XMLUni::fgXMLChEncodingString), XMLRecognizer::XERCES_XMLCH);
  220|      1|    gMappings->put((void*)XMLUni::fgXMLChEncodingString, new ENameMapFor<XMLChTranscoder>(XMLUni::fgXMLChEncodingString));
  221|       |
  222|       |    //
  223|       |    //  Add in our mappings for ASCII.
  224|       |    //
  225|      1|    gMappingsRecognizer->setElementAt(new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString), XMLRecognizer::US_ASCII);
  226|      1|    gMappings->put((void*)XMLUni::fgUSASCIIEncodingString, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString));
  227|      1|    gMappings->put((void*)XMLUni::fgUSASCIIEncodingString2, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString2));
  228|      1|    gMappings->put((void*)XMLUni::fgUSASCIIEncodingString3, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString3));
  229|      1|    gMappings->put((void*)XMLUni::fgUSASCIIEncodingString4, new ENameMapFor<XMLASCIITranscoder>(XMLUni::fgUSASCIIEncodingString4));
  230|       |
  231|       |
  232|       |    //
  233|       |    //  Add in our mappings for UTF-8
  234|       |    //
  235|      1|    gMappingsRecognizer->setElementAt(new ENameMapFor<XMLUTF8Transcoder>(XMLUni::fgUTF8EncodingString), XMLRecognizer::UTF_8);
  236|      1|    gMappings->put((void*)XMLUni::fgUTF8EncodingString, new ENameMapFor<XMLUTF8Transcoder>(XMLUni::fgUTF8EncodingString));
  237|      1|    gMappings->put((void*)XMLUni::fgUTF8EncodingString2, new ENameMapFor<XMLUTF8Transcoder>(XMLUni::fgUTF8EncodingString2));
  238|       |
  239|       |    //
  240|       |    //  Add in our mappings for Latin1
  241|       |    //
  242|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString));
  243|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString2, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString2));
  244|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString3, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString3));
  245|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString4, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString4));
  246|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString5, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString5));
  247|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString6, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString6));
  248|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString7, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString7));
  249|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString8, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString8));
  250|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString9, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString9));
  251|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString10, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString10));
  252|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString11, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString11));
  253|      1|    gMappings->put((void*)XMLUni::fgISO88591EncodingString12, new ENameMapFor<XML88591Transcoder>(XMLUni::fgISO88591EncodingString12));
  254|       |
  255|       |    //
  256|       |    //  Add in our mappings for UTF-16 and UCS-4, little endian
  257|       |    //
  258|      1|    bool swapped = XMLPlatformUtils::fgXMLChBigEndian;
  259|       |
  260|      1|    gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUTF16Transcoder>(XMLUni::fgUTF16LEncodingString, swapped), XMLRecognizer::UTF_16L);
  261|      1|    gMappings->put
  262|      1|    (
  263|      1|        (void*)XMLUni::fgUTF16LEncodingString,
  264|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  265|      1|        (
  266|      1|            XMLUni::fgUTF16LEncodingString
  267|      1|            , swapped
  268|      1|        )
  269|      1|    );
  270|       |
  271|      1|    gMappings->put
  272|      1|    (
  273|      1|        (void*)XMLUni::fgUTF16LEncodingString2,
  274|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  275|      1|        (
  276|      1|            XMLUni::fgUTF16LEncodingString2
  277|      1|            , swapped
  278|      1|        )
  279|      1|    );
  280|       |
  281|      1|    gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUCS4Transcoder>(XMLUni::fgUCS4LEncodingString, swapped), XMLRecognizer::UCS_4L);
  282|      1|    gMappings->put
  283|      1|    (
  284|      1|        (void*)XMLUni::fgUCS4LEncodingString,
  285|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  286|      1|        (
  287|      1|            XMLUni::fgUCS4LEncodingString
  288|      1|            , swapped
  289|      1|        )
  290|      1|    );
  291|       |
  292|      1|    gMappings->put
  293|      1|    (
  294|      1|        (void*)XMLUni::fgUCS4LEncodingString2,
  295|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  296|      1|        (
  297|      1|            XMLUni::fgUCS4LEncodingString2
  298|      1|            , swapped
  299|      1|        )
  300|      1|    );
  301|       |
  302|       |    //
  303|       |    //  Add in our mappings for UTF-16 and UCS-4, big endian
  304|       |    //
  305|      1|    swapped = !XMLPlatformUtils::fgXMLChBigEndian;
  306|       |
  307|      1|    gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUTF16Transcoder>(XMLUni::fgUTF16BEncodingString, swapped), XMLRecognizer::UTF_16B);
  308|      1|    gMappings->put
  309|      1|    (
  310|      1|        (void*)XMLUni::fgUTF16BEncodingString,
  311|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  312|      1|        (
  313|      1|            XMLUni::fgUTF16BEncodingString
  314|      1|            , swapped
  315|      1|        )
  316|      1|    );
  317|       |
  318|      1|    gMappings->put
  319|      1|    (
  320|      1|        (void*)XMLUni::fgUTF16BEncodingString2,
  321|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  322|      1|        (
  323|      1|            XMLUni::fgUTF16BEncodingString2
  324|      1|            , swapped
  325|      1|        )
  326|      1|    );
  327|       |
  328|      1|    gMappingsRecognizer->setElementAt(new EEndianNameMapFor<XMLUCS4Transcoder>(XMLUni::fgUCS4BEncodingString, swapped), XMLRecognizer::UCS_4B);
  329|      1|    gMappings->put
  330|      1|    (
  331|      1|        (void*)XMLUni::fgUCS4BEncodingString,
  332|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  333|      1|        (
  334|      1|            XMLUni::fgUCS4BEncodingString
  335|      1|            , swapped
  336|      1|        )
  337|      1|    );
  338|       |
  339|      1|    gMappings->put
  340|      1|    (
  341|      1|        (void*)XMLUni::fgUCS4BEncodingString2,
  342|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  343|      1|        (
  344|      1|            XMLUni::fgUCS4BEncodingString2
  345|      1|            , swapped
  346|      1|        )
  347|      1|    );
  348|       |
  349|       |    //
  350|       |    //  Add in our mappings for UTF-16 and UCS-4 which does not indicate endian
  351|       |    //  assumes the same endian encoding as the OS
  352|       |    //
  353|       |
  354|      1|    gMappings->put
  355|      1|    (
  356|      1|        (void*)XMLUni::fgUTF16EncodingString,
  357|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  358|      1|        (
  359|      1|            XMLUni::fgUTF16EncodingString
  360|      1|            , false
  361|      1|        )
  362|      1|    );
  363|      1|    gMappings->put
  364|      1|    (
  365|      1|        (void*)XMLUni::fgUTF16EncodingString2,
  366|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  367|      1|        (
  368|      1|            XMLUni::fgUTF16EncodingString2
  369|      1|            , false
  370|      1|        )
  371|      1|    );
  372|      1|    gMappings->put
  373|      1|    (
  374|      1|        (void*)XMLUni::fgUTF16EncodingString3,
  375|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  376|      1|        (
  377|      1|            XMLUni::fgUTF16EncodingString3
  378|      1|            , false
  379|      1|        )
  380|      1|    );
  381|      1|    gMappings->put
  382|      1|    (
  383|      1|        (void*)XMLUni::fgUTF16EncodingString4,
  384|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  385|      1|        (
  386|      1|            XMLUni::fgUTF16EncodingString4
  387|      1|            , false
  388|      1|        )
  389|      1|    );
  390|      1|    gMappings->put
  391|      1|    (
  392|      1|        (void*)XMLUni::fgUTF16EncodingString5,
  393|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  394|      1|        (
  395|      1|            XMLUni::fgUTF16EncodingString5
  396|      1|            , false
  397|      1|        )
  398|      1|    );
  399|      1|    gMappings->put
  400|      1|    (
  401|      1|        (void*)XMLUni::fgUTF16EncodingString6,
  402|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  403|      1|        (
  404|      1|            XMLUni::fgUTF16EncodingString6
  405|      1|            , false
  406|      1|        )
  407|      1|    );
  408|      1|    gMappings->put
  409|      1|    (
  410|      1|        (void*)XMLUni::fgUTF16EncodingString7,
  411|      1|        new EEndianNameMapFor<XMLUTF16Transcoder>
  412|      1|        (
  413|      1|            XMLUni::fgUTF16EncodingString7
  414|      1|            , false
  415|      1|        )
  416|      1|    );
  417|      1|    gMappings->put
  418|      1|    (
  419|      1|        (void*)XMLUni::fgUCS4EncodingString,
  420|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  421|      1|        (
  422|      1|            XMLUni::fgUCS4EncodingString
  423|      1|            , false
  424|      1|        )
  425|      1|    );
  426|      1|    gMappings->put
  427|      1|    (
  428|      1|        (void*)XMLUni::fgUCS4EncodingString2,
  429|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  430|      1|        (
  431|      1|            XMLUni::fgUCS4EncodingString2
  432|      1|            , false
  433|      1|        )
  434|      1|    );
  435|      1|    gMappings->put
  436|      1|    (
  437|      1|        (void*)XMLUni::fgUCS4EncodingString3,
  438|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  439|      1|        (
  440|      1|            XMLUni::fgUCS4EncodingString3
  441|      1|            , false
  442|      1|        )
  443|      1|    );
  444|      1|    gMappings->put
  445|      1|    (
  446|      1|        (void*)XMLUni::fgUCS4EncodingString4,
  447|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  448|      1|        (
  449|      1|            XMLUni::fgUCS4EncodingString4
  450|      1|            , false
  451|      1|        )
  452|      1|    );
  453|      1|    gMappings->put
  454|      1|    (
  455|      1|        (void*)XMLUni::fgUCS4EncodingString5,
  456|      1|        new EEndianNameMapFor<XMLUCS4Transcoder>
  457|      1|        (
  458|      1|            XMLUni::fgUCS4EncodingString5
  459|      1|            , false
  460|      1|        )
  461|      1|    );
  462|       |
  463|       |    //
  464|       |    //  Add in our mappings for IBM037, and the one alias we support for
  465|       |    //  it, which is EBCDIC-CP-US.
  466|       |    //
  467|      1|    gMappingsRecognizer->setElementAt(new ENameMapFor<XMLEBCDICTranscoder>(XMLUni::fgEBCDICEncodingString), XMLRecognizer::EBCDIC);
  468|      1|    gMappings->put((void*)XMLUni::fgIBM037EncodingString, new ENameMapFor<XMLEBCDICTranscoder>(XMLUni::fgIBM037EncodingString));
  469|      1|    gMappings->put((void*)XMLUni::fgIBM037EncodingString2, new ENameMapFor<XMLEBCDICTranscoder>(XMLUni::fgIBM037EncodingString2));
  470|       |
  471|       |
  472|       |    //hhe
  473|      1|    gMappings->put((void*)XMLUni::fgIBM1047EncodingString, new ENameMapFor<XMLIBM1047Transcoder>(XMLUni::fgIBM1047EncodingString));
  474|      1|    gMappings->put((void*)XMLUni::fgIBM1047EncodingString2, new ENameMapFor<XMLIBM1047Transcoder>(XMLUni::fgIBM1047EncodingString2));
  475|       |
  476|       |    //
  477|       |    //  Add in our mappings for IBM037 with Euro update, i.e. IBM1140. It
  478|       |    //  has alias IBM01140, the one suggested by IANA
  479|       |    //
  480|      1|    gMappings->put((void*)XMLUni::fgIBM1140EncodingString, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString));
  481|      1|    gMappings->put((void*)XMLUni::fgIBM1140EncodingString2, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString2));
  482|      1|    gMappings->put((void*)XMLUni::fgIBM1140EncodingString3, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString3));
  483|      1|    gMappings->put((void*)XMLUni::fgIBM1140EncodingString4, new ENameMapFor<XMLIBM1140Transcoder>(XMLUni::fgIBM1140EncodingString4));
  484|       |
  485|       |    //
  486|       |    //  Add in our mappings for Windows-1252. We don't have any aliases for
  487|       |    //  this one, so there is just one mapping.
  488|       |    //
  489|      1|    gMappings->put((void*)XMLUni::fgWin1252EncodingString, new ENameMapFor<XMLWin1252Transcoder>(XMLUni::fgWin1252EncodingString));
  490|       |
  491|      1|}
_ZN11xercesc_3_213XMLTranscoderD2Ev:
  510|  25.2k|{
  511|  25.2k|    fMemoryManager->deallocate(fEncodingName);//delete [] fEncodingName;
  512|  25.2k|}
_ZN11xercesc_3_213XMLTranscoderC2EPKDsmPNS_13MemoryManagerE:
  524|  25.2k|{
  525|  25.2k|    fEncodingName = XMLString::replicate(encodingName, fMemoryManager);
  526|  25.2k|}
_ZN11xercesc_3_216XMLLCPTranscoderC2Ev:
  538|      1|{
  539|      1|}

_ZNK11xercesc_3_213XMLTranscoder16getMemoryManagerEv:
  650|  12.5k|{
  651|  12.5k|    return fMemoryManager;
  652|  12.5k|}
_ZNK11xercesc_3_213XMLTranscoder15getEncodingNameEv:
  663|     25|{
  664|     25|    return fEncodingName;
  665|     25|}

_ZN11xercesc_3_215IconvGNUWrapperC2EPNS_13MemoryManagerE:
  173|      1|{
  174|      1|}
_ZN11xercesc_3_215IconvGNUWrapperC2EPvS1_mjPNS_13MemoryManagerE:
  183|  7.25k|{
  184|  7.25k|    if (fCDFrom == (iconv_t) -1 || fCDTo == (iconv_t) -1) {
  ------------------
  |  Branch (184:9): [True: 0, False: 7.25k]
  |  Branch (184:36): [True: 0, False: 7.25k]
  ------------------
  185|      0|        XMLPlatformUtils::panic (PanicHandler::Panic_NoTransService);
  186|      0|    }
  187|  7.25k|}
_ZN11xercesc_3_215IconvGNUWrapperD2Ev:
  190|  7.25k|{
  191|  7.25k|}
_ZN11xercesc_3_215IconvGNUWrapper9iconvFromEPKcPmPPcm:
  382|  32.6M|{
  383|       |#if ICONV_USES_CONST_POINTER
  384|       |    const char ** tmpPtr = &fromPtr;
  385|       |#else
  386|  32.6M|    char ** tmpPtr = (char**)&fromPtr;
  387|  32.6M|#endif
  388|  32.6M|    return ::iconv (fCDFrom, tmpPtr, fromLen, toPtr, &toLen);
  389|  32.6M|}
_ZN11xercesc_3_215IconvGNUWrapper7iconvToEPKcPmPPcm:
  395|  21.3k|{
  396|       |#if ICONV_USES_CONST_POINTER
  397|       |    const char ** tmpPtr = &fromPtr;
  398|       |#else
  399|  21.3k|    char ** tmpPtr = (char**)&fromPtr;
  400|  21.3k|#endif
  401|  21.3k|    return ::iconv (fCDTo, tmpPtr, fromLen, toPtr, &toLen);
  402|  21.3k|}
_ZN11xercesc_3_220IconvGNUTransServiceC2EPNS_13MemoryManagerE:
  411|      1|{
  412|       |    // Try to obtain local (host) characterset from the setlocale
  413|       |    // and through the environment. Do not call setlocale(LC_*, "")!
  414|       |    // Using an empty string instead of NULL, will modify the libc
  415|       |    // behavior.
  416|       |    //
  417|      1|    const char* fLocalCP = setlocale (LC_CTYPE, NULL);
  418|      1|    if (fLocalCP == NULL || *fLocalCP == 0 ||
  ------------------
  |  Branch (418:9): [True: 0, False: 1]
  |  Branch (418:29): [True: 0, False: 1]
  ------------------
  419|      1|        strcmp (fLocalCP, "C") == 0 ||
  ------------------
  |  Branch (419:9): [True: 1, False: 0]
  ------------------
  420|      1|        strcmp (fLocalCP, "POSIX") == 0) {
  ------------------
  |  Branch (420:9): [True: 0, False: 0]
  ------------------
  421|      1|      fLocalCP = getenv ("LC_ALL");
  422|      1|      if (fLocalCP == NULL) {
  ------------------
  |  Branch (422:11): [True: 1, False: 0]
  ------------------
  423|      1|        fLocalCP = getenv ("LC_CTYPE");
  424|      1|        if (fLocalCP == NULL)
  ------------------
  |  Branch (424:13): [True: 1, False: 0]
  ------------------
  425|      1|          fLocalCP = getenv ("LANG");
  426|      1|      }
  427|      1|    }
  428|       |
  429|      1|    if (fLocalCP == NULL || *fLocalCP == 0 ||
  ------------------
  |  Branch (429:9): [True: 1, False: 0]
  |  Branch (429:29): [True: 0, False: 0]
  ------------------
  430|      1|        strcmp (fLocalCP, "C") == 0 ||
  ------------------
  |  Branch (430:9): [True: 0, False: 0]
  ------------------
  431|      1|        strcmp (fLocalCP, "POSIX") == 0)
  ------------------
  |  Branch (431:9): [True: 0, False: 0]
  ------------------
  432|      1|        fLocalCP = "iso-8859-1";    // fallback locale
  433|      0|    else {
  434|      0|        const char *ptr = strchr (fLocalCP, '.');
  435|      0|        if (ptr == NULL)
  ------------------
  |  Branch (435:13): [True: 0, False: 0]
  ------------------
  436|      0|            fLocalCP = "iso-8859-1";    // fallback locale
  437|      0|        else
  438|      0|            fLocalCP = ptr + 1;
  439|      0|    }
  440|       |
  441|       |    // Select the native unicode characters encoding schema
  442|      1|    const IconvGNUEncoding    *eptr;
  443|       |    // first - try to use the schema with character size equal to XMLCh, and same endianness
  444|      1|    for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++)
  ------------------
  |  Branch (444:37): [True: 1, False: 0]
  ------------------
  445|      1|    {
  446|      1|        if (eptr->fUChSize != sizeof(XMLCh) || eptr->fUBO != BYTE_ORDER)
  ------------------
  |  Branch (446:13): [True: 0, False: 1]
  |  Branch (446:48): [True: 0, False: 1]
  ------------------
  447|      0|            continue;
  448|       |
  449|       |        // try to create conversion descriptor
  450|      1|        iconv_t    cd_to = iconv_open(fLocalCP, eptr->fSchema);
  451|      1|        if (cd_to == (iconv_t)-1)
  ------------------
  |  Branch (451:13): [True: 0, False: 1]
  ------------------
  452|      0|            continue;
  453|      1|        iconv_t    cd_from = iconv_open(eptr->fSchema, fLocalCP);
  454|      1|        if (cd_from == (iconv_t)-1) {
  ------------------
  |  Branch (454:13): [True: 0, False: 1]
  ------------------
  455|      0|            iconv_close (cd_to);
  456|      0|            continue;
  457|      0|        }
  458|       |
  459|       |        // got it
  460|      1|        setUChSize(eptr->fUChSize);
  461|      1|        setUBO(eptr->fUBO);
  462|      1|        setCDTo(cd_to);
  463|      1|        setCDFrom(cd_from);
  464|      1|        fUnicodeCP = eptr->fSchema;
  465|      1|        break;
  466|      1|    }
  467|      1|    if (fUnicodeCP == NULL)
  ------------------
  |  Branch (467:9): [True: 0, False: 1]
  ------------------
  468|       |        // try to use any known schema
  469|      0|        for (eptr = gIconvGNUEncodings; eptr->fSchema; eptr++)
  ------------------
  |  Branch (469:41): [True: 0, False: 0]
  ------------------
  470|      0|        {
  471|       |            // try to create conversion descriptor
  472|      0|            iconv_t    cd_to = iconv_open(fLocalCP, eptr->fSchema);
  473|      0|            if (cd_to == (iconv_t)-1)
  ------------------
  |  Branch (473:17): [True: 0, False: 0]
  ------------------
  474|      0|                continue;
  475|      0|            iconv_t    cd_from = iconv_open(eptr->fSchema, fLocalCP);
  476|      0|            if (cd_from == (iconv_t)-1) {
  ------------------
  |  Branch (476:17): [True: 0, False: 0]
  ------------------
  477|      0|                iconv_close (cd_to);
  478|      0|                continue;
  479|      0|            }
  480|       |
  481|       |            // got it
  482|      0|            setUChSize(eptr->fUChSize);
  483|      0|            setUBO(eptr->fUBO);
  484|      0|            setCDTo(cd_to);
  485|      0|            setCDFrom(cd_from);
  486|      0|            fUnicodeCP = eptr->fSchema;
  487|      0|            break;
  488|      0|        }
  489|       |
  490|      1|    if (fUnicodeCP == NULL || cdTo() == (iconv_t)-1 || cdFrom() == (iconv_t)-1)
  ------------------
  |  Branch (490:9): [True: 0, False: 1]
  |  Branch (490:31): [True: 0, False: 1]
  |  Branch (490:56): [True: 0, False: 1]
  ------------------
  491|      0|        XMLPlatformUtils::panic (PanicHandler::Panic_NoTransService);
  492|      1|}
_ZN11xercesc_3_220IconvGNUTransService20makeNewLCPTranscoderEPNS_13MemoryManagerE:
  573|      1|{
  574|      1|    return new (manager) IconvGNULCPTranscoder (cdFrom(), cdTo(), uChSize(), UBO(), manager);
  575|      1|}
_ZNK11xercesc_3_220IconvGNUTransService14supportsSrcOfsEv:
  578|  25.4k|{
  579|  25.4k|    return true;
  580|  25.4k|}
_ZN11xercesc_3_220IconvGNUTransService20makeNewXMLTranscoderEPKDsRNS_15XMLTransService5CodesEmPNS_13MemoryManagerE:
  593|  7.33k|{
  594|  7.33k|    resValue = XMLTransService::UnsupportedEncoding;
  595|  7.33k|    IconvGNUTranscoder    *newTranscoder = NULL;
  596|       |
  597|  7.33k|    char    *encLocal = XMLString::transcode(encodingName, manager);
  598|  7.33k|    ArrayJanitor<char> janBuf(encLocal, manager);
  599|  7.33k|    iconv_t    cd_from, cd_to;
  600|       |
  601|  7.33k|    cd_from = iconv_open (fUnicodeCP, encLocal);
  602|  7.33k|    if (cd_from == (iconv_t)-1) {
  ------------------
  |  Branch (602:9): [True: 78, False: 7.25k]
  ------------------
  603|     78|        resValue = XMLTransService::SupportFilesNotFound;
  604|     78|        return NULL;
  605|     78|    }
  606|  7.25k|    cd_to = iconv_open (encLocal, fUnicodeCP);
  607|  7.25k|    if (cd_to == (iconv_t)-1) {
  ------------------
  |  Branch (607:9): [True: 0, False: 7.25k]
  ------------------
  608|      0|        resValue = XMLTransService::SupportFilesNotFound;
  609|      0|        iconv_close (cd_from);
  610|      0|        return NULL;
  611|      0|    }
  612|  7.25k|    newTranscoder = new (manager) IconvGNUTranscoder (encodingName,
  613|  7.25k|                         blockSize,
  614|  7.25k|                         cd_from, cd_to,
  615|  7.25k|                         uChSize(), UBO(), manager);
  616|  7.25k|    if (newTranscoder)
  ------------------
  |  Branch (616:9): [True: 7.25k, False: 0]
  ------------------
  617|  7.25k|        resValue = XMLTransService::Ok;
  618|  7.25k|    return newTranscoder;
  619|  7.25k|}
_ZN11xercesc_3_221IconvGNULCPTranscoder16calcRequiredSizeEPKcPNS_13MemoryManagerE:
  652|  9.32k|{
  653|  9.32k|    if (!srcText)
  ------------------
  |  Branch (653:9): [True: 0, False: 9.32k]
  ------------------
  654|      0|        return 0;
  655|       |
  656|  9.32k|    size_t len, srcLen;
  657|  9.32k|    len = srcLen = strlen(srcText);
  658|  9.32k|    if (len == 0)
  ------------------
  |  Branch (658:9): [True: 0, False: 9.32k]
  ------------------
  659|      0|        return 0;
  660|       |
  661|  9.32k|    char tmpWideArr[gTempBuffArraySize];
  662|  9.32k|    size_t totalLen = 0;
  663|       |
  664|  9.32k|    XMLMutexLock lockConverter(&fMutex);
  665|       |
  666|  9.32k|    for (;;) {
  667|  9.32k|        char        *pTmpArr = tmpWideArr;
  668|  9.32k|        const char    *ptr = srcText + srcLen - len;
  669|  9.32k|        size_t    rc = iconvFrom(ptr, &len, &pTmpArr, gTempBuffArraySize);
  670|  9.32k|        if (rc == (size_t) -1 && errno != E2BIG) {
  ------------------
  |  Branch (670:13): [True: 0, False: 9.32k]
  |  Branch (670:34): [True: 0, False: 0]
  ------------------
  671|      0|            ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  672|       |            /* return 0; */
  673|      0|        }
  674|  9.32k|        rc = pTmpArr - (char *) tmpWideArr;
  675|  9.32k|        totalLen += rc;
  676|  9.32k|        if (rc == 0 || len == 0)
  ------------------
  |  Branch (676:13): [True: 0, False: 9.32k]
  |  Branch (676:24): [True: 9.32k, False: 0]
  ------------------
  677|  9.32k|            break;
  678|  9.32k|    }
  679|  9.32k|    return totalLen / uChSize();
  680|  9.32k|}
_ZN11xercesc_3_221IconvGNULCPTranscoder16calcRequiredSizeEPKDsPNS_13MemoryManagerE:
  685|  9.87k|{
  686|  9.87k|    if (!srcText)
  ------------------
  |  Branch (686:9): [True: 0, False: 9.87k]
  ------------------
  687|      0|        return 0;
  688|  9.87k|    XMLSize_t  wLent = getWideCharLength(srcText);
  689|  9.87k|    if (wLent == 0)
  ------------------
  |  Branch (689:9): [True: 0, False: 9.87k]
  ------------------
  690|      0|        return 0;
  691|       |
  692|  9.87k|    char    tmpWBuff[gTempBuffArraySize];
  693|  9.87k|    char    *wBuf = 0;
  694|  9.87k|    char    *wBufPtr = 0;
  695|  9.87k|    ArrayJanitor<char>  janBuf(wBufPtr, manager);
  696|  9.87k|    size_t      len = wLent * uChSize();
  697|  9.87k|    if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  ------------------
  |  Branch (697:9): [True: 0, False: 9.87k]
  |  Branch (697:39): [True: 0, False: 9.87k]
  ------------------
  698|      0|        if (len > gTempBuffArraySize) {
  ------------------
  |  Branch (698:13): [True: 0, False: 0]
  ------------------
  699|      0|            wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
  700|      0|            janBuf.reset(wBufPtr, manager);
  701|      0|            wBuf = wBufPtr;
  702|      0|        } else
  703|      0|            wBuf = tmpWBuff;
  704|      0|        xmlToMbs (srcText, wBuf, wLent);
  705|      0|    } else
  706|  9.87k|        wBuf = (char *) srcText;
  707|       |
  708|  9.87k|    char    tmpBuff[gTempBuffArraySize];
  709|  9.87k|    size_t    totalLen = 0;
  710|  9.87k|    char    *srcEnd = wBuf + wLent * uChSize();
  711|       |
  712|  9.87k|    XMLMutexLock lockConverter(&fMutex);
  713|       |
  714|  11.6k|    for (;;) {
  715|  11.6k|        char        *pTmpArr = tmpBuff;
  716|  11.6k|        const char    *ptr = srcEnd - len;
  717|  11.6k|        size_t    rc = iconvTo(ptr, &len, &pTmpArr, gTempBuffArraySize);
  718|  11.6k|        if (rc == (size_t) -1 && errno != E2BIG) {
  ------------------
  |  Branch (718:13): [True: 1.99k, False: 9.68k]
  |  Branch (718:34): [True: 185, False: 1.81k]
  ------------------
  719|    185|            ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, manager);
  ------------------
  |  |  264|    185|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  720|       |            /* return 0; */
  721|    185|        }
  722|  11.4k|        rc = pTmpArr - tmpBuff;
  723|  11.4k|        totalLen += rc;
  724|  11.4k|        if (rc == 0 || len == 0)
  ------------------
  |  Branch (724:13): [True: 0, False: 11.4k]
  |  Branch (724:24): [True: 9.68k, False: 1.81k]
  ------------------
  725|  9.68k|            break;
  726|  11.4k|    }
  727|  9.68k|    return totalLen;
  728|  9.87k|}
_ZN11xercesc_3_221IconvGNULCPTranscoder9transcodeEPKDsPNS_13MemoryManagerE:
  733|  9.87k|{
  734|  9.87k|    if (!toTranscode)
  ------------------
  |  Branch (734:9): [True: 0, False: 9.87k]
  ------------------
  735|      0|        return 0;
  736|       |
  737|  9.87k|    char* retVal = 0;
  738|  9.87k|    if (!*toTranscode) {
  ------------------
  |  Branch (738:9): [True: 1, False: 9.87k]
  ------------------
  739|      1|        retVal = (char*) manager->allocate(sizeof(char));//new char[1];
  740|      1|        retVal[0] = 0;
  741|      1|        return retVal;
  742|      1|    }
  743|       |
  744|  9.87k|    XMLSize_t wLent = getWideCharLength(toTranscode);
  745|       |
  746|       |    // Calc needed size.
  747|  9.87k|    XMLSize_t neededLen = calcRequiredSize (toTranscode, manager);
  748|  9.87k|    if (neededLen == 0)
  ------------------
  |  Branch (748:9): [True: 0, False: 9.87k]
  ------------------
  749|      0|        return 0;
  750|       |    // allocate output buffer
  751|  9.87k|    retVal = (char*) manager->allocate((neededLen + 1) * sizeof(char));//new char[neededLen + 1];
  752|       |    // prepare the original
  753|  9.87k|    char    tmpWBuff[gTempBuffArraySize];
  754|  9.87k|    char    *wideCharBuf = 0;
  755|  9.87k|    char    *wBufPtr = 0;
  756|  9.87k|    ArrayJanitor<char>  janBuf(wBufPtr, manager);
  757|  9.87k|    size_t  len = wLent * uChSize();
  758|       |
  759|  9.87k|    if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  ------------------
  |  Branch (759:9): [True: 185, False: 9.68k]
  |  Branch (759:39): [True: 0, False: 9.68k]
  ------------------
  760|      0|        if (len > gTempBuffArraySize) {
  ------------------
  |  Branch (760:13): [True: 0, False: 0]
  ------------------
  761|      0|            wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
  762|      0|            janBuf.reset(wBufPtr, manager);
  763|      0|            wideCharBuf = wBufPtr;
  764|      0|        } else
  765|      0|            wideCharBuf = tmpWBuff;
  766|      0|        xmlToMbs (toTranscode, wideCharBuf, wLent);
  767|      0|    } else
  768|  9.87k|        wideCharBuf = (char *) toTranscode;
  769|       |
  770|       |    // perform conversion
  771|  9.87k|    char* ptr = retVal;
  772|  9.87k|    size_t rc;
  773|       |
  774|  9.87k|    {
  775|  9.87k|      XMLMutexLock lockConverter(&fMutex);
  776|  9.87k|      rc = iconvTo(wideCharBuf, &len, &ptr, neededLen);
  777|  9.87k|    }
  778|       |
  779|  9.87k|    if (rc == (size_t)-1) {
  ------------------
  |  Branch (779:9): [True: 0, False: 9.87k]
  ------------------
  780|      0|        return 0;
  781|      0|    }
  782|  9.87k|    retVal[neededLen] = 0;
  783|       |
  784|  9.87k|    return retVal;
  785|  9.87k|}
_ZN11xercesc_3_221IconvGNULCPTranscoder9transcodeEPKcPNS_13MemoryManagerE:
  846|  9.32k|{
  847|  9.32k|    if (!toTranscode)
  ------------------
  |  Branch (847:9): [True: 0, False: 9.32k]
  ------------------
  848|      0|        return 0;
  849|       |
  850|  9.32k|    XMLCh* retVal = 0;
  851|  9.32k|    if (!*toTranscode) {
  ------------------
  |  Branch (851:9): [True: 1, False: 9.32k]
  ------------------
  852|      1|        retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
  853|      1|        retVal[0] = 0;
  854|      1|        return retVal;
  855|      1|    }
  856|       |
  857|  9.32k|    XMLSize_t wLent = calcRequiredSize(toTranscode, manager);
  858|  9.32k|    if (wLent == 0) {
  ------------------
  |  Branch (858:9): [True: 0, False: 9.32k]
  ------------------
  859|      0|        retVal = (XMLCh*) manager->allocate(sizeof(XMLCh));//new XMLCh[1];
  860|      0|        retVal[0] = 0;
  861|      0|        return retVal;
  862|      0|    }
  863|       |
  864|  9.32k|    char    tmpWBuff[gTempBuffArraySize];
  865|  9.32k|    char    *wideCharBuf = 0;
  866|  9.32k|    char    *wBufPtr = 0;
  867|  9.32k|    ArrayJanitor<char>  janBuf(wBufPtr, manager);
  868|  9.32k|    size_t  len = wLent * uChSize();
  869|       |
  870|  9.32k|    retVal = (XMLCh*) manager->allocate((wLent + 1) * sizeof(XMLCh));//new XMLCh[wLent + 1];
  871|  9.32k|    if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  ------------------
  |  Branch (871:9): [True: 0, False: 9.32k]
  |  Branch (871:39): [True: 0, False: 9.32k]
  ------------------
  872|      0|        if (len > gTempBuffArraySize) {
  ------------------
  |  Branch (872:13): [True: 0, False: 0]
  ------------------
  873|      0|            wBufPtr = (char*) manager->allocate(len * sizeof(char));//new char[len];
  874|      0|            janBuf.reset(wBufPtr, manager);
  875|      0|            wideCharBuf = wBufPtr;
  876|      0|        } else
  877|      0|            wideCharBuf = tmpWBuff;
  878|      0|    } else
  879|  9.32k|        wideCharBuf = (char *) retVal;
  880|       |
  881|  9.32k|    size_t    flen = strlen(toTranscode);
  882|  9.32k|    char    *ptr = wideCharBuf;
  883|  9.32k|    size_t rc;
  884|       |
  885|  9.32k|    {
  886|  9.32k|      XMLMutexLock lockConverter(&fMutex);
  887|  9.32k|      rc = iconvFrom(toTranscode, &flen, &ptr, len);
  888|  9.32k|    }
  889|       |
  890|  9.32k|    if (rc == (size_t) -1) {
  ------------------
  |  Branch (890:9): [True: 0, False: 9.32k]
  ------------------
  891|      0|        return NULL;
  892|      0|    }
  893|  9.32k|    if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  ------------------
  |  Branch (893:9): [True: 0, False: 9.32k]
  |  Branch (893:39): [True: 0, False: 9.32k]
  ------------------
  894|      0|        mbsToXML (wideCharBuf, retVal, wLent);
  895|  9.32k|    retVal[wLent] = 0x00;
  896|       |
  897|  9.32k|    return retVal;
  898|  9.32k|}
_ZN11xercesc_3_221IconvGNULCPTranscoderC2EPvS1_mjPNS_13MemoryManagerE:
  971|      1|{
  972|      1|}
_ZN11xercesc_3_218IconvGNUTranscoderC2EPKDsmPvS3_mjPNS_13MemoryManagerE:
  993|  7.25k|{
  994|  7.25k|}
_ZN11xercesc_3_218IconvGNUTranscoderD2Ev:
  997|  7.25k|{
  998|  7.25k|    if (cdTo() != (iconv_t)-1) {
  ------------------
  |  Branch (998:9): [True: 7.25k, False: 0]
  ------------------
  999|  7.25k|        iconv_close (cdTo());
 1000|  7.25k|        setCDTo ((iconv_t)-1);
 1001|  7.25k|    }
 1002|  7.25k|    if (cdFrom() != (iconv_t)-1) {
  ------------------
  |  Branch (1002:9): [True: 7.25k, False: 0]
  ------------------
 1003|  7.25k|        iconv_close (cdFrom());
 1004|  7.25k|        setCDFrom ((iconv_t)-1);
 1005|  7.25k|    }
 1006|  7.25k|}
_ZN11xercesc_3_218IconvGNUTranscoder13transcodeFromEPKhmPDsmRmPh:
 1019|  12.1k|{
 1020|       |    // Transcode TO XMLCh
 1021|  12.1k|    const char*  startSrc = (const char*) srcData;
 1022|  12.1k|    const char*  endSrc = (const char*) srcData + srcCount;
 1023|       |
 1024|  12.1k|    char    tmpWBuff[gTempBuffArraySize];
 1025|  12.1k|    char    *startTarget = 0;
 1026|  12.1k|    char    *wBufPtr = 0;
 1027|  12.1k|    ArrayJanitor<char>  janBuf(wBufPtr, getMemoryManager());
 1028|  12.1k|    size_t    len = maxChars * uChSize();
 1029|       |
 1030|  12.1k|    if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER) {
  ------------------
  |  Branch (1030:9): [True: 0, False: 12.1k]
  |  Branch (1030:39): [True: 0, False: 12.1k]
  ------------------
 1031|      0|        if (len > gTempBuffArraySize) {
  ------------------
  |  Branch (1031:13): [True: 0, False: 0]
  ------------------
 1032|      0|            wBufPtr = (char*) getMemoryManager()->allocate(len * sizeof(char));//new char[len];
 1033|      0|            janBuf.reset(wBufPtr, getMemoryManager());
 1034|      0|            startTarget = wBufPtr;
 1035|      0|        } else
 1036|      0|            startTarget = tmpWBuff;
 1037|      0|    } else
 1038|  12.1k|        startTarget = (char *) toFill;
 1039|       |
 1040|       |    // Do character-by-character transcoding
 1041|  12.1k|    char    *orgTarget = startTarget;
 1042|  12.1k|    size_t    srcLen = srcCount;
 1043|  12.1k|    size_t    prevSrcLen = srcLen;
 1044|  12.1k|    XMLSize_t toReturn = 0;
 1045|  12.1k|    bytesEaten = 0;
 1046|       |
 1047|  12.1k|    XMLMutexLock lockConverter(&fMutex);
 1048|       |
 1049|  32.6M|    for (size_t cnt = 0; cnt < maxChars && srcLen; cnt++) {
  ------------------
  |  Branch (1049:26): [True: 32.6M, False: 1.50k]
  |  Branch (1049:44): [True: 32.6M, False: 10.4k]
  ------------------
 1050|  32.6M|        size_t    rc = iconvFrom(startSrc, &srcLen, &orgTarget, uChSize());
 1051|  32.6M|        if (rc == (size_t)-1) {
  ------------------
  |  Branch (1051:13): [True: 32.6M, False: 10.7k]
  ------------------
 1052|  32.6M|            if (errno == EINVAL && cnt > 0)
  ------------------
  |  Branch (1052:17): [True: 130, False: 32.6M]
  |  Branch (1052:36): [True: 127, False: 3]
  ------------------
 1053|    127|                break;
 1054|  32.6M|            if (errno != E2BIG || prevSrcLen == srcLen) {
  ------------------
  |  Branch (1054:17): [True: 37, False: 32.6M]
  |  Branch (1054:35): [True: 1, False: 32.6M]
  ------------------
 1055|     38|                ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
  ------------------
  |  |  264|     38|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1056|     38|            }
 1057|  32.6M|        }
 1058|  32.6M|        charSizes[cnt] = prevSrcLen - srcLen;
 1059|  32.6M|        prevSrcLen = srcLen;
 1060|  32.6M|        bytesEaten += charSizes[cnt];
 1061|  32.6M|        startSrc = endSrc - srcLen;
 1062|  32.6M|        toReturn++;
 1063|  32.6M|    }
 1064|  12.1k|    if (uChSize() != sizeof(XMLCh) || UBO() != BYTE_ORDER)
  ------------------
  |  Branch (1064:9): [True: 0, False: 12.1k]
  |  Branch (1064:39): [True: 0, False: 12.1k]
  ------------------
 1065|      0|        mbsToXML (startTarget, toFill, toReturn);
 1066|  12.1k|    return toReturn;
 1067|  12.1k|}
IconvGNUTransService.cpp:_ZN11xercesc_3_2L17getWideCharLengthEPKDs:
  153|  19.7k|{
  154|  19.7k|    if (!src)
  ------------------
  |  Branch (154:9): [True: 0, False: 19.7k]
  ------------------
  155|      0|        return 0;
  156|       |
  157|  19.7k|    XMLSize_t len = 0;
  158|  19.7k|    const XMLCh* pTmp = src;
  159|  27.9M|    while (*pTmp++)
  ------------------
  |  Branch (159:12): [True: 27.8M, False: 19.7k]
  ------------------
  160|  27.8M|        len++;
  161|  19.7k|    return len;
  162|  19.7k|}

_ZNK11xercesc_3_215IconvGNUWrapper4cdToEv:
   77|  14.5k|    inline iconv_t	cdTo () const { return fCDTo; }
_ZNK11xercesc_3_215IconvGNUWrapper6cdFromEv:
   78|  14.5k|    inline iconv_t	cdFrom () const { return fCDFrom; }
_ZNK11xercesc_3_215IconvGNUWrapper7uChSizeEv:
   79|  32.7M|    inline size_t	uChSize () const { return fUChSize; }
_ZNK11xercesc_3_215IconvGNUWrapper3UBOEv:
   80|  69.7k|    inline unsigned int	UBO () const { return fUBO; }
_ZN11xercesc_3_215IconvGNUWrapper7setCDToEPv:
  117|  7.25k|    inline void	setCDTo (iconv_t cd) { fCDTo = cd; }
_ZN11xercesc_3_215IconvGNUWrapper9setCDFromEPv:
  118|  7.25k|    inline void	setCDFrom (iconv_t cd) { fCDFrom = cd; }
_ZN11xercesc_3_215IconvGNUWrapper10setUChSizeEm:
  119|      1|    inline void	setUChSize (size_t sz) { fUChSize = sz; }
_ZN11xercesc_3_215IconvGNUWrapper6setUBOEj:
  120|      1|    inline void	setUBO (unsigned int u) { fUBO = u; }

_ZN11xercesc_3_216ValueHashTableOfINS_7XSValue8DataTypeENS_12StringHasherEE14findBucketElemEPKvRm:
  273|     44|{
  274|       |    // Hash the key
  275|     44|    hashVal = fHasher.getHashVal(key, fHashModulus);
  276|     44|    assert(hashVal < fHashModulus);
  277|       |
  278|       |    // Search that bucket for the key
  279|      0|    ValueHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  280|     63|    while (curElem)
  ------------------
  |  Branch (280:12): [True: 19, False: 44]
  ------------------
  281|     19|    {
  282|     19|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (282:13): [True: 0, False: 19]
  ------------------
  283|      0|            return curElem;
  284|       |
  285|     19|        curElem = curElem->fNext;
  286|     19|    }
  287|     44|    return 0;
  288|     44|}
_ZN11xercesc_3_216ValueHashTableOfINS_7XSValue8DataTypeENS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   63|      1|{
   64|      1|    initialize(modulus);
   65|      1|}
_ZN11xercesc_3_216ValueHashTableOfINS_7XSValue8DataTypeENS_12StringHasherEE10initializeEm:
   69|      1|{
   70|      1|    if (modulus == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 1]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|       |    // Allocate the bucket list and zero them
   74|      1|    fBucketList = (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
   75|      1|    (
   76|      1|        fHashModulus * sizeof(ValueHashTableBucketElem<TVal>*)
   77|      1|    ); //new ValueHashTableBucketElem<TVal>*[fHashModulus];
   78|      1|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
   79|      1|}
_ZN11xercesc_3_216ValueHashTableOfINS_7XSValue8DataTypeENS_12StringHasherEE3putEPvRKS2_:
  180|     44|{
  181|       |    // Apply 0.75 load factor to find threshold.
  182|     44|    XMLSize_t threshold = fHashModulus * 3 / 4;
  183|       |
  184|       |    // If we've grown too big, expand the table and rehash.
  185|     44|    if (fCount >= threshold)
  ------------------
  |  Branch (185:9): [True: 1, False: 43]
  ------------------
  186|      1|        rehash();
  187|       |
  188|       |    // First see if the key exists already
  189|     44|    XMLSize_t hashVal;
  190|     44|    ValueHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  191|       |
  192|       |    //
  193|       |    //  If so,then update its value. If not, then we need to add it to
  194|       |    //  the right bucket
  195|       |    //
  196|     44|    if (newBucket)
  ------------------
  |  Branch (196:9): [True: 0, False: 44]
  ------------------
  197|      0|    {
  198|      0|        newBucket->fData = valueToAdopt;
  199|      0|        newBucket->fKey = key;
  200|      0|    }
  201|     44|     else
  202|     44|    {
  203|     44|        newBucket =
  204|     44|            new (fMemoryManager->allocate(sizeof(ValueHashTableBucketElem<TVal>)))
  205|     44|            ValueHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  206|     44|        fBucketList[hashVal] = newBucket;
  207|     44|        fCount++;
  208|     44|    }
  209|     44|}
_ZN11xercesc_3_216ValueHashTableOfINS_7XSValue8DataTypeENS_12StringHasherEE6rehashEv:
  218|      1|{
  219|      1|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  220|       |
  221|      1|    ValueHashTableBucketElem<TVal>** newBucketList =
  222|      1|        (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
  223|      1|    (
  224|      1|        newMod * sizeof(ValueHashTableBucketElem<TVal>*)
  225|      1|    );//new RefHashTableBucketElem<TVal>*[newMod];
  226|       |
  227|       |    // Make sure the new bucket list is destroyed if an
  228|       |    // exception is thrown.
  229|      1|    ArrayJanitor<ValueHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  230|       |
  231|      1|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  232|       |
  233|       |
  234|       |    // Rehash all existing entries.
  235|     44|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (235:31): [True: 43, False: 1]
  ------------------
  236|     43|    {
  237|       |        // Get the bucket list head for this entry
  238|     43|        ValueHashTableBucketElem<TVal>* curElem = fBucketList[index];
  239|       |
  240|     75|        while (curElem)
  ------------------
  |  Branch (240:16): [True: 32, False: 43]
  ------------------
  241|     32|        {
  242|       |            // Save the next element before we detach this one
  243|     32|            ValueHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  244|       |
  245|     32|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  246|     32|            assert(hashVal < newMod);
  247|       |
  248|      0|            ValueHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  249|       |
  250|       |            // Insert at the start of this bucket's list.
  251|     32|            curElem->fNext = newHeadElem;
  252|     32|            newBucketList[hashVal] = curElem;
  253|       |
  254|     32|            curElem = nextElem;
  255|     32|        }
  256|     43|    }
  257|       |
  258|      1|    ValueHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  259|       |
  260|       |    // Everything is OK at this point, so update the
  261|       |    // member variables.
  262|      1|    fBucketList = guard.release();
  263|      1|    fHashModulus = newMod;
  264|       |
  265|       |    // Delete the old bucket list.
  266|      1|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  267|       |
  268|      1|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_9PtrHasherEED2Ev:
   83|  8.51k|{
   84|  8.51k|    removeAll();
   85|       |
   86|       |    // Then delete the bucket list & hasher
   87|  8.51k|    fMemoryManager->deallocate(fBucketList); //delete [] fBucketList;
   88|  8.51k|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_9PtrHasherEE9removeAllEv:
  119|  8.51k|{
  120|  8.51k|    if(isEmpty())
  ------------------
  |  Branch (120:8): [True: 8.51k, False: 0]
  ------------------
  121|  8.51k|        return;
  122|       |
  123|       |    // Clean up the buckets first
  124|      0|    for (XMLSize_t buckInd = 0; buckInd < fHashModulus; buckInd++)
  ------------------
  |  Branch (124:33): [True: 0, False: 0]
  ------------------
  125|      0|    {
  126|       |        // Get the bucket list head for this entry
  127|      0|        ValueHashTableBucketElem<TVal>* curElem = fBucketList[buckInd];
  128|      0|        ValueHashTableBucketElem<TVal>* nextElem;
  129|      0|        while (curElem)
  ------------------
  |  Branch (129:16): [True: 0, False: 0]
  ------------------
  130|      0|        {
  131|       |            // Save the next element before we hose this one
  132|      0|            nextElem = curElem->fNext;
  133|       |
  134|       |            // delete the current element and move forward
  135|       |            // destructor is empty...
  136|       |            // curElem->~ValueHashTableBucketElem();
  137|      0|            fMemoryManager->deallocate(curElem);
  138|      0|            curElem = nextElem;
  139|      0|        }
  140|       |
  141|       |        // Clean out this entry
  142|      0|        fBucketList[buckInd] = 0;
  143|      0|    }
  144|      0|    fCount = 0;
  145|      0|}
_ZNK11xercesc_3_216ValueHashTableOfIbNS_9PtrHasherEE7isEmptyEv:
   96|  8.51k|{
   97|  8.51k|    return fCount==0;
   98|  8.51k|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_9PtrHasherEEC2EmPNS_13MemoryManagerE:
   63|  8.51k|{
   64|  8.51k|    initialize(modulus);
   65|  8.51k|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_9PtrHasherEE10initializeEm:
   69|  8.51k|{
   70|  8.51k|    if (modulus == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 8.51k]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|       |    // Allocate the bucket list and zero them
   74|  8.51k|    fBucketList = (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
   75|  8.51k|    (
   76|  8.51k|        fHashModulus * sizeof(ValueHashTableBucketElem<TVal>*)
   77|  8.51k|    ); //new ValueHashTableBucketElem<TVal>*[fHashModulus];
   78|  8.51k|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
   79|  8.51k|}
_ZN11xercesc_3_216ValueHashTableOfItNS_12StringHasherEE14findBucketElemEPKvRm:
  273|     46|{
  274|       |    // Hash the key
  275|     46|    hashVal = fHasher.getHashVal(key, fHashModulus);
  276|     46|    assert(hashVal < fHashModulus);
  277|       |
  278|       |    // Search that bucket for the key
  279|      0|    ValueHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  280|     60|    while (curElem)
  ------------------
  |  Branch (280:12): [True: 14, False: 46]
  ------------------
  281|     14|    {
  282|     14|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (282:13): [True: 0, False: 14]
  ------------------
  283|      0|            return curElem;
  284|       |
  285|     14|        curElem = curElem->fNext;
  286|     14|    }
  287|     46|    return 0;
  288|     46|}
_ZN11xercesc_3_216ValueHashTableOfItNS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   63|      2|{
   64|      2|    initialize(modulus);
   65|      2|}
_ZN11xercesc_3_216ValueHashTableOfItNS_12StringHasherEE10initializeEm:
   69|      2|{
   70|      2|    if (modulus == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 2]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|       |    // Allocate the bucket list and zero them
   74|      2|    fBucketList = (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
   75|      2|    (
   76|      2|        fHashModulus * sizeof(ValueHashTableBucketElem<TVal>*)
   77|      2|    ); //new ValueHashTableBucketElem<TVal>*[fHashModulus];
   78|      2|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
   79|      2|}
_ZN11xercesc_3_216ValueHashTableOfItNS_12StringHasherEE3putEPvRKt:
  180|     46|{
  181|       |    // Apply 0.75 load factor to find threshold.
  182|     46|    XMLSize_t threshold = fHashModulus * 3 / 4;
  183|       |
  184|       |    // If we've grown too big, expand the table and rehash.
  185|     46|    if (fCount >= threshold)
  ------------------
  |  Branch (185:9): [True: 2, False: 44]
  ------------------
  186|      2|        rehash();
  187|       |
  188|       |    // First see if the key exists already
  189|     46|    XMLSize_t hashVal;
  190|     46|    ValueHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  191|       |
  192|       |    //
  193|       |    //  If so,then update its value. If not, then we need to add it to
  194|       |    //  the right bucket
  195|       |    //
  196|     46|    if (newBucket)
  ------------------
  |  Branch (196:9): [True: 0, False: 46]
  ------------------
  197|      0|    {
  198|      0|        newBucket->fData = valueToAdopt;
  199|      0|        newBucket->fKey = key;
  200|      0|    }
  201|     46|     else
  202|     46|    {
  203|     46|        newBucket =
  204|     46|            new (fMemoryManager->allocate(sizeof(ValueHashTableBucketElem<TVal>)))
  205|     46|            ValueHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  206|     46|        fBucketList[hashVal] = newBucket;
  207|     46|        fCount++;
  208|     46|    }
  209|     46|}
_ZN11xercesc_3_216ValueHashTableOfItNS_12StringHasherEE6rehashEv:
  218|      2|{
  219|      2|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  220|       |
  221|      2|    ValueHashTableBucketElem<TVal>** newBucketList =
  222|      2|        (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
  223|      2|    (
  224|      2|        newMod * sizeof(ValueHashTableBucketElem<TVal>*)
  225|      2|    );//new RefHashTableBucketElem<TVal>*[newMod];
  226|       |
  227|       |    // Make sure the new bucket list is destroyed if an
  228|       |    // exception is thrown.
  229|      2|    ArrayJanitor<ValueHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  230|       |
  231|      2|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  232|       |
  233|       |
  234|       |    // Rehash all existing entries.
  235|     49|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (235:31): [True: 47, False: 2]
  ------------------
  236|     47|    {
  237|       |        // Get the bucket list head for this entry
  238|     47|        ValueHashTableBucketElem<TVal>* curElem = fBucketList[index];
  239|       |
  240|     81|        while (curElem)
  ------------------
  |  Branch (240:16): [True: 34, False: 47]
  ------------------
  241|     34|        {
  242|       |            // Save the next element before we detach this one
  243|     34|            ValueHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  244|       |
  245|     34|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  246|     34|            assert(hashVal < newMod);
  247|       |
  248|      0|            ValueHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  249|       |
  250|       |            // Insert at the start of this bucket's list.
  251|     34|            curElem->fNext = newHeadElem;
  252|     34|            newBucketList[hashVal] = curElem;
  253|       |
  254|     34|            curElem = nextElem;
  255|     34|        }
  256|     47|    }
  257|       |
  258|      2|    ValueHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  259|       |
  260|       |    // Everything is OK at this point, so update the
  261|       |    // member variables.
  262|      2|    fBucketList = guard.release();
  263|      2|    fHashModulus = newMod;
  264|       |
  265|       |    // Delete the old bucket list.
  266|      2|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  267|       |
  268|      2|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_12StringHasherEEC2EmPNS_13MemoryManagerE:
   63|      1|{
   64|      1|    initialize(modulus);
   65|      1|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_12StringHasherEE10initializeEm:
   69|      1|{
   70|      1|    if (modulus == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 1]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::HshTbl_ZeroModulus, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|       |    // Allocate the bucket list and zero them
   74|      1|    fBucketList = (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
   75|      1|    (
   76|      1|        fHashModulus * sizeof(ValueHashTableBucketElem<TVal>*)
   77|      1|    ); //new ValueHashTableBucketElem<TVal>*[fHashModulus];
   78|      1|    memset(fBucketList, 0, sizeof(fBucketList[0]) * fHashModulus);
   79|      1|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_12StringHasherEE3putEPvRKb:
  180|    791|{
  181|       |    // Apply 0.75 load factor to find threshold.
  182|    791|    XMLSize_t threshold = fHashModulus * 3 / 4;
  183|       |
  184|       |    // If we've grown too big, expand the table and rehash.
  185|    791|    if (fCount >= threshold)
  ------------------
  |  Branch (185:9): [True: 4, False: 787]
  ------------------
  186|      4|        rehash();
  187|       |
  188|       |    // First see if the key exists already
  189|    791|    XMLSize_t hashVal;
  190|    791|    ValueHashTableBucketElem<TVal>* newBucket = findBucketElem(key, hashVal);
  191|       |
  192|       |    //
  193|       |    //  If so,then update its value. If not, then we need to add it to
  194|       |    //  the right bucket
  195|       |    //
  196|    791|    if (newBucket)
  ------------------
  |  Branch (196:9): [True: 0, False: 791]
  ------------------
  197|      0|    {
  198|      0|        newBucket->fData = valueToAdopt;
  199|      0|        newBucket->fKey = key;
  200|      0|    }
  201|    791|     else
  202|    791|    {
  203|    791|        newBucket =
  204|    791|            new (fMemoryManager->allocate(sizeof(ValueHashTableBucketElem<TVal>)))
  205|    791|            ValueHashTableBucketElem<TVal>(key, valueToAdopt, fBucketList[hashVal]);
  206|    791|        fBucketList[hashVal] = newBucket;
  207|    791|        fCount++;
  208|    791|    }
  209|    791|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_12StringHasherEE6rehashEv:
  218|      4|{
  219|      4|    const XMLSize_t newMod = (fHashModulus * 2) + 1;
  220|       |
  221|      4|    ValueHashTableBucketElem<TVal>** newBucketList =
  222|      4|        (ValueHashTableBucketElem<TVal>**) fMemoryManager->allocate
  223|      4|    (
  224|      4|        newMod * sizeof(ValueHashTableBucketElem<TVal>*)
  225|      4|    );//new RefHashTableBucketElem<TVal>*[newMod];
  226|       |
  227|       |    // Make sure the new bucket list is destroyed if an
  228|       |    // exception is thrown.
  229|      4|    ArrayJanitor<ValueHashTableBucketElem<TVal>*>  guard(newBucketList, fMemoryManager);
  230|       |
  231|      4|    memset(newBucketList, 0, newMod * sizeof(newBucketList[0]));
  232|       |
  233|       |
  234|       |    // Rehash all existing entries.
  235|  1.65k|    for (XMLSize_t index = 0; index < fHashModulus; index++)
  ------------------
  |  Branch (235:31): [True: 1.64k, False: 4]
  ------------------
  236|  1.64k|    {
  237|       |        // Get the bucket list head for this entry
  238|  1.64k|        ValueHashTableBucketElem<TVal>* curElem = fBucketList[index];
  239|       |
  240|  2.87k|        while (curElem)
  ------------------
  |  Branch (240:16): [True: 1.23k, False: 1.64k]
  ------------------
  241|  1.23k|        {
  242|       |            // Save the next element before we detach this one
  243|  1.23k|            ValueHashTableBucketElem<TVal>* const nextElem = curElem->fNext;
  244|       |
  245|  1.23k|            const XMLSize_t hashVal = fHasher.getHashVal(curElem->fKey, newMod);
  246|  1.23k|            assert(hashVal < newMod);
  247|       |
  248|      0|            ValueHashTableBucketElem<TVal>* const newHeadElem = newBucketList[hashVal];
  249|       |
  250|       |            // Insert at the start of this bucket's list.
  251|  1.23k|            curElem->fNext = newHeadElem;
  252|  1.23k|            newBucketList[hashVal] = curElem;
  253|       |
  254|  1.23k|            curElem = nextElem;
  255|  1.23k|        }
  256|  1.64k|    }
  257|       |
  258|      4|    ValueHashTableBucketElem<TVal>** const oldBucketList = fBucketList;
  259|       |
  260|       |    // Everything is OK at this point, so update the
  261|       |    // member variables.
  262|      4|    fBucketList = guard.release();
  263|      4|    fHashModulus = newMod;
  264|       |
  265|       |    // Delete the old bucket list.
  266|      4|    fMemoryManager->deallocate(oldBucketList);//delete[] oldBucketList;
  267|       |
  268|      4|}
_ZN11xercesc_3_216ValueHashTableOfIbNS_12StringHasherEE14findBucketElemEPKvRm:
  273|    791|{
  274|       |    // Hash the key
  275|    791|    hashVal = fHasher.getHashVal(key, fHashModulus);
  276|    791|    assert(hashVal < fHashModulus);
  277|       |
  278|       |    // Search that bucket for the key
  279|      0|    ValueHashTableBucketElem<TVal>* curElem = fBucketList[hashVal];
  280|  1.20k|    while (curElem)
  ------------------
  |  Branch (280:12): [True: 410, False: 791]
  ------------------
  281|    410|    {
  282|    410|        if (fHasher.equals(key, curElem->fKey))
  ------------------
  |  Branch (282:13): [True: 0, False: 410]
  ------------------
  283|      0|            return curElem;
  284|       |
  285|    410|        curElem = curElem->fNext;
  286|    410|    }
  287|    791|    return 0;
  288|    791|}

_ZN11xercesc_3_224ValueHashTableBucketElemINS_7XSValue8DataTypeEEC2EPvRKS2_PS3_:
   49|     44|        {
   50|     44|        }
_ZN11xercesc_3_224ValueHashTableBucketElemIbEC2EPvRKbPS1_:
   49|    791|        {
   50|    791|        }
_ZN11xercesc_3_224ValueHashTableBucketElemItEC2EPvRKtPS1_:
   49|     46|        {
   50|     46|        }

_ZN11xercesc_3_212ValueStackOfImED2Ev:
   46|  1.32k|{
   47|  1.32k|}
_ZN11xercesc_3_212ValueStackOfImEC2EmPNS_13MemoryManagerEb:
   42|  3.54k|{
   43|  3.54k|}
_ZN11xercesc_3_212ValueStackOfImE4pushERKm:
   54|  14.5k|{
   55|  14.5k|    fVector.addElement(toPush);
   56|  14.5k|}
_ZN11xercesc_3_212ValueStackOfImE3popEv:
   68|  2.96k|{
   69|  2.96k|    const XMLSize_t curSize = fVector.size();
   70|  2.96k|    if (curSize == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 2.96k]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|  2.96k|    TElem retVal = fVector.elementAt(curSize-1);
   74|  2.96k|    fVector.removeElementAt(curSize-1);
   75|  2.96k|    return retVal;
   76|  2.96k|}
_ZN11xercesc_3_212ValueStackOfINS_16formatNodeHolderEEC2EmPNS_13MemoryManagerEb:
   42|  1.35k|{
   43|  1.35k|}
_ZN11xercesc_3_212ValueStackOfINS_16formatNodeHolderEE4pushERKS1_:
   54|  3.81M|{
   55|  3.81M|    fVector.addElement(toPush);
   56|  3.81M|}
_ZN11xercesc_3_212ValueStackOfINS_16formatNodeHolderEE5emptyEv:
   88|  3.81M|{
   89|  3.81M|    return (fVector.size() == 0);
   90|  3.81M|}
_ZN11xercesc_3_212ValueStackOfINS_16formatNodeHolderEE3popEv:
   68|  3.81M|{
   69|  3.81M|    const XMLSize_t curSize = fVector.size();
   70|  3.81M|    if (curSize == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 3.81M]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|  3.81M|    TElem retVal = fVector.elementAt(curSize-1);
   74|  3.81M|    fVector.removeElementAt(curSize-1);
   75|  3.81M|    return retVal;
   76|  3.81M|}
_ZN11xercesc_3_212ValueStackOfINS_16formatNodeHolderEED2Ev:
   46|  1.35k|{
   47|  1.35k|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ContentSpecNodeEEC2EmPNS_13MemoryManagerEb:
   42|  7.65k|{
   43|  7.65k|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ContentSpecNodeEED2Ev:
   46|  7.65k|{
   47|  7.65k|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ContentSpecNodeEE4pushERKS2_:
   54|  6.11M|{
   55|  6.11M|    fVector.addElement(toPush);
   56|  6.11M|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ContentSpecNodeEE5emptyEv:
   88|  6.12M|{
   89|  6.12M|    return (fVector.size() == 0);
   90|  6.12M|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ContentSpecNodeEE3popEv:
   68|  6.11M|{
   69|  6.11M|    const XMLSize_t curSize = fVector.size();
   70|  6.11M|    if (curSize == 0)
  ------------------
  |  Branch (70:9): [True: 0, False: 6.11M]
  ------------------
   71|      0|        ThrowXMLwithMemMgr(EmptyStackException, XMLExcepts::Stack_EmptyStack, fVector.getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   72|       |
   73|  6.11M|    TElem retVal = fVector.elementAt(curSize-1);
   74|  6.11M|    fVector.removeElementAt(curSize-1);
   75|  6.11M|    return retVal;
   76|  6.11M|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ComplexTypeInfoEEC2EmPNS_13MemoryManagerEb:
   42|  8.51k|{
   43|  8.51k|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ComplexTypeInfoEED2Ev:
   46|  8.51k|{
   47|  8.51k|}
_ZN11xercesc_3_212ValueStackOfIPNS_15ComplexTypeInfoEE17removeAllElementsEv:
   79|  8.51k|{
   80|  8.51k|    fVector.removeAllElements();
   81|  8.51k|}
_ZN11xercesc_3_212ValueStackOfIbED2Ev:
   46|  8.51k|{
   47|  8.51k|}
_ZN11xercesc_3_212ValueStackOfIbEC2EmPNS_13MemoryManagerEb:
   42|  8.51k|{
   43|  8.51k|}
_ZN11xercesc_3_212ValueStackOfImE5emptyEv:
   88|  8.12k|{
   89|  8.12k|    return (fVector.size() == 0);
   90|  8.12k|}
_ZN11xercesc_3_212ValueStackOfIiEC2EmPNS_13MemoryManagerEb:
   42|  8.51k|{
   43|  8.51k|}
_ZN11xercesc_3_212ValueStackOfIiED2Ev:
   46|  8.51k|{
   47|  8.51k|}
_ZN11xercesc_3_212ValueStackOfIiE17removeAllElementsEv:
   79|  8.51k|{
   80|  8.51k|    fVector.removeAllElements();
   81|  8.51k|}

_ZN11xercesc_3_213ValueVectorOfIiEC2EmPNS_13MemoryManagerEb:
   46|  8.51k|{
   47|  8.51k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  8.51k|    (
   49|  8.51k|        fMaxCount * sizeof(TElem)
   50|  8.51k|    ); //new TElem[fMaxCount];
   51|       |
   52|  8.51k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIiED2Ev:
   75|  8.51k|{
   76|  8.51k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 8.51k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  8.51k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_13SchemaGrammarEEC2EmPNS_13MemoryManagerEb:
   46|  8.51k|{
   47|  8.51k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  8.51k|    (
   49|  8.51k|        fMaxCount * sizeof(TElem)
   50|  8.51k|    ); //new TElem[fMaxCount];
   51|       |
   52|  8.51k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_13SchemaGrammarEED2Ev:
   75|  8.51k|{
   76|  8.51k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 8.51k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  8.51k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_13SchemaGrammarEE17removeAllElementsEv:
  171|  8.51k|{
  172|  8.51k|    fCurCount = 0;
  173|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPDsEC2EmPNS_13MemoryManagerEb:
   46|  8.51k|{
   47|  8.51k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  8.51k|    (
   49|  8.51k|        fMaxCount * sizeof(TElem)
   50|  8.51k|    ); //new TElem[fMaxCount];
   51|       |
   52|  8.51k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPDsED2Ev:
   75|  8.51k|{
   76|  8.51k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 8.51k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  8.51k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfImED2Ev:
   75|  1.32k|{
   76|  1.32k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 1.32k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  1.32k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  1.32k|}
_ZN11xercesc_3_213ValueVectorOfImEC2EmPNS_13MemoryManagerEb:
   46|  3.54k|{
   47|  3.54k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  3.54k|    (
   49|  3.54k|        fMaxCount * sizeof(TElem)
   50|  3.54k|    ); //new TElem[fMaxCount];
   51|       |
   52|  3.54k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  3.54k|}
_ZN11xercesc_3_213ValueVectorOfImE10addElementERKm:
  121|  14.5k|{
  122|  14.5k|    ensureExtraCapacity(1);
  123|  14.5k|    fElemList[fCurCount++] = toAdd;
  124|  14.5k|}
_ZN11xercesc_3_213ValueVectorOfImE19ensureExtraCapacityEm:
  229|  14.5k|{
  230|  14.5k|    XMLSize_t newMax = fCurCount + length;
  231|       |
  232|  14.5k|    if (newMax > fMaxCount)
  ------------------
  |  Branch (232:9): [True: 2.60k, False: 11.9k]
  ------------------
  233|  2.60k|    {
  234|       |        // Avoid too many reallocations by expanding by a percentage
  235|  2.60k|        XMLSize_t minNewMax = (XMLSize_t)((double)fCurCount * 1.25);
  236|  2.60k|        if (newMax < minNewMax)
  ------------------
  |  Branch (236:13): [True: 1.09k, False: 1.51k]
  ------------------
  237|  1.09k|            newMax = minNewMax;
  238|       |
  239|  2.60k|        TElem* newList = (TElem*) fMemoryManager->allocate
  240|  2.60k|        (
  241|  2.60k|            newMax * sizeof(TElem)
  242|  2.60k|        ); //new TElem[newMax];
  243|  37.2k|        for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (243:35): [True: 34.6k, False: 2.60k]
  ------------------
  244|  34.6k|            newList[index] = fElemList[index];
  245|       |
  246|  2.60k|        fMemoryManager->deallocate(fElemList); //delete [] fElemList;
  247|  2.60k|        fElemList = newList;
  248|  2.60k|        fMaxCount = newMax;
  249|  2.60k|    }
  250|  14.5k|}
_ZNK11xercesc_3_213ValueVectorOfImE4sizeEv:
  214|  11.0k|{
  215|  11.0k|    return fCurCount;
  216|  11.0k|}
_ZN11xercesc_3_213ValueVectorOfImE9elementAtEm:
  202|  2.96k|{
  203|  2.96k|    if (getAt >= fCurCount)
  ------------------
  |  Branch (203:9): [True: 0, False: 2.96k]
  ------------------
  204|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  205|  2.96k|    return fElemList[getAt];
  206|  2.96k|}
_ZN11xercesc_3_213ValueVectorOfImE15removeElementAtEm:
  158|  2.96k|{
  159|  2.96k|    if (removeAt >= fCurCount)
  ------------------
  |  Branch (159:9): [True: 0, False: 2.96k]
  ------------------
  160|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  161|       |
  162|       |    // Copy down every element above remove point
  163|  2.96k|    for (XMLSize_t index = removeAt; index < fCurCount-1; index++)
  ------------------
  |  Branch (163:38): [True: 0, False: 2.96k]
  ------------------
  164|      0|        fElemList[index] = fElemList[index+1];
  165|       |
  166|       |    // And bump down count
  167|  2.96k|    fCurCount--;
  168|  2.96k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_11PrefMapElemEEC2EmPNS_13MemoryManagerEb:
   46|  8.51k|{
   47|  8.51k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  8.51k|    (
   49|  8.51k|        fMaxCount * sizeof(TElem)
   50|  8.51k|    ); //new TElem[fMaxCount];
   51|       |
   52|  8.51k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_11PrefMapElemEED2Ev:
   75|  8.51k|{
   76|  8.51k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 8.51k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  8.51k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_5QNameEEC2EmPNS_13MemoryManagerEb:
   46|    108|{
   47|    108|    fElemList = (TElem*) fMemoryManager->allocate
   48|    108|    (
   49|    108|        fMaxCount * sizeof(TElem)
   50|    108|    ); //new TElem[fMaxCount];
   51|       |
   52|    108|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|    108|}
_ZN11xercesc_3_213ValueVectorOfIPNS_5QNameEED2Ev:
   75|    108|{
   76|    108|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 108]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|    108|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|    108|}
_ZN11xercesc_3_213ValueVectorOfIbEC2EmPNS_13MemoryManagerEb:
   46|  8.51k|{
   47|  8.51k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  8.51k|    (
   49|  8.51k|        fMaxCount * sizeof(TElem)
   50|  8.51k|    ); //new TElem[fMaxCount];
   51|       |
   52|  8.51k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIbED2Ev:
   75|  8.51k|{
   76|  8.51k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 8.51k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  8.51k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  8.51k|}
_ZNK11xercesc_3_213ValueVectorOfIPNS_5QNameEE4sizeEv:
  214|    108|{
  215|    108|    return fCurCount;
  216|    108|}
_ZN11xercesc_3_213ValueVectorOfIPNS_5QNameEE9elementAtEm:
  202|  46.8k|{
  203|  46.8k|    if (getAt >= fCurCount)
  ------------------
  |  Branch (203:9): [True: 0, False: 46.8k]
  ------------------
  204|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  205|  46.8k|    return fElemList[getAt];
  206|  46.8k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_5QNameEE10addElementERKS2_:
  121|  46.8k|{
  122|  46.8k|    ensureExtraCapacity(1);
  123|  46.8k|    fElemList[fCurCount++] = toAdd;
  124|  46.8k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_5QNameEE19ensureExtraCapacityEm:
  229|  46.8k|{
  230|  46.8k|    XMLSize_t newMax = fCurCount + length;
  231|       |
  232|  46.8k|    if (newMax > fMaxCount)
  ------------------
  |  Branch (232:9): [True: 358, False: 46.5k]
  ------------------
  233|    358|    {
  234|       |        // Avoid too many reallocations by expanding by a percentage
  235|    358|        XMLSize_t minNewMax = (XMLSize_t)((double)fCurCount * 1.25);
  236|    358|        if (newMax < minNewMax)
  ------------------
  |  Branch (236:13): [True: 358, False: 0]
  ------------------
  237|    358|            newMax = minNewMax;
  238|       |
  239|    358|        TElem* newList = (TElem*) fMemoryManager->allocate
  240|    358|        (
  241|    358|            newMax * sizeof(TElem)
  242|    358|        ); //new TElem[newMax];
  243|   199k|        for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (243:35): [True: 199k, False: 358]
  ------------------
  244|   199k|            newList[index] = fElemList[index];
  245|       |
  246|    358|        fMemoryManager->deallocate(fElemList); //delete [] fElemList;
  247|    358|        fElemList = newList;
  248|    358|        fMaxCount = newMax;
  249|    358|    }
  250|  46.8k|}
_ZN11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEEC2EmPNS_13MemoryManagerEb:
   46|  1.35k|{
   47|  1.35k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  1.35k|    (
   49|  1.35k|        fMaxCount * sizeof(TElem)
   50|  1.35k|    ); //new TElem[fMaxCount];
   51|       |
   52|  1.35k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  1.35k|}
_ZN11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEE10addElementERKS1_:
  121|  3.81M|{
  122|  3.81M|    ensureExtraCapacity(1);
  123|  3.81M|    fElemList[fCurCount++] = toAdd;
  124|  3.81M|}
_ZN11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEE19ensureExtraCapacityEm:
  229|  3.81M|{
  230|  3.81M|    XMLSize_t newMax = fCurCount + length;
  231|       |
  232|  3.81M|    if (newMax > fMaxCount)
  ------------------
  |  Branch (232:9): [True: 1.18k, False: 3.81M]
  ------------------
  233|  1.18k|    {
  234|       |        // Avoid too many reallocations by expanding by a percentage
  235|  1.18k|        XMLSize_t minNewMax = (XMLSize_t)((double)fCurCount * 1.25);
  236|  1.18k|        if (newMax < minNewMax)
  ------------------
  |  Branch (236:13): [True: 1.18k, False: 0]
  ------------------
  237|  1.18k|            newMax = minNewMax;
  238|       |
  239|  1.18k|        TElem* newList = (TElem*) fMemoryManager->allocate
  240|  1.18k|        (
  241|  1.18k|            newMax * sizeof(TElem)
  242|  1.18k|        ); //new TElem[newMax];
  243|  20.6k|        for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (243:35): [True: 19.4k, False: 1.18k]
  ------------------
  244|  19.4k|            newList[index] = fElemList[index];
  245|       |
  246|  1.18k|        fMemoryManager->deallocate(fElemList); //delete [] fElemList;
  247|  1.18k|        fElemList = newList;
  248|  1.18k|        fMaxCount = newMax;
  249|  1.18k|    }
  250|  3.81M|}
_ZNK11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEE4sizeEv:
  214|  7.62M|{
  215|  7.62M|    return fCurCount;
  216|  7.62M|}
_ZN11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEE9elementAtEm:
  202|  3.81M|{
  203|  3.81M|    if (getAt >= fCurCount)
  ------------------
  |  Branch (203:9): [True: 0, False: 3.81M]
  ------------------
  204|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  205|  3.81M|    return fElemList[getAt];
  206|  3.81M|}
_ZN11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEE15removeElementAtEm:
  158|  3.81M|{
  159|  3.81M|    if (removeAt >= fCurCount)
  ------------------
  |  Branch (159:9): [True: 0, False: 3.81M]
  ------------------
  160|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  161|       |
  162|       |    // Copy down every element above remove point
  163|  3.81M|    for (XMLSize_t index = removeAt; index < fCurCount-1; index++)
  ------------------
  |  Branch (163:38): [True: 0, False: 3.81M]
  ------------------
  164|      0|        fElemList[index] = fElemList[index+1];
  165|       |
  166|       |    // And bump down count
  167|  3.81M|    fCurCount--;
  168|  3.81M|}
_ZN11xercesc_3_213ValueVectorOfINS_16formatNodeHolderEED2Ev:
   75|  1.35k|{
   76|  1.35k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 1.35k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  1.35k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  1.35k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEEC2EmPNS_13MemoryManagerEb:
   46|  7.65k|{
   47|  7.65k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  7.65k|    (
   49|  7.65k|        fMaxCount * sizeof(TElem)
   50|  7.65k|    ); //new TElem[fMaxCount];
   51|       |
   52|  7.65k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  7.65k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEED2Ev:
   75|  7.65k|{
   76|  7.65k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 7.65k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  7.65k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  7.65k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEE10addElementERKS2_:
  121|  6.11M|{
  122|  6.11M|    ensureExtraCapacity(1);
  123|  6.11M|    fElemList[fCurCount++] = toAdd;
  124|  6.11M|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEE19ensureExtraCapacityEm:
  229|  6.11M|{
  230|  6.11M|    XMLSize_t newMax = fCurCount + length;
  231|       |
  232|  6.11M|    if (newMax > fMaxCount)
  ------------------
  |  Branch (232:9): [True: 13.2k, False: 6.10M]
  ------------------
  233|  13.2k|    {
  234|       |        // Avoid too many reallocations by expanding by a percentage
  235|  13.2k|        XMLSize_t minNewMax = (XMLSize_t)((double)fCurCount * 1.25);
  236|  13.2k|        if (newMax < minNewMax)
  ------------------
  |  Branch (236:13): [True: 13.2k, False: 0]
  ------------------
  237|  13.2k|            newMax = minNewMax;
  238|       |
  239|  13.2k|        TElem* newList = (TElem*) fMemoryManager->allocate
  240|  13.2k|        (
  241|  13.2k|            newMax * sizeof(TElem)
  242|  13.2k|        ); //new TElem[newMax];
  243|  3.26M|        for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (243:35): [True: 3.25M, False: 13.2k]
  ------------------
  244|  3.25M|            newList[index] = fElemList[index];
  245|       |
  246|  13.2k|        fMemoryManager->deallocate(fElemList); //delete [] fElemList;
  247|  13.2k|        fElemList = newList;
  248|  13.2k|        fMaxCount = newMax;
  249|  13.2k|    }
  250|  6.11M|}
_ZNK11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEE4sizeEv:
  214|  12.2M|{
  215|  12.2M|    return fCurCount;
  216|  12.2M|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEE9elementAtEm:
  202|  6.11M|{
  203|  6.11M|    if (getAt >= fCurCount)
  ------------------
  |  Branch (203:9): [True: 0, False: 6.11M]
  ------------------
  204|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  205|  6.11M|    return fElemList[getAt];
  206|  6.11M|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ContentSpecNodeEE15removeElementAtEm:
  158|  6.11M|{
  159|  6.11M|    if (removeAt >= fCurCount)
  ------------------
  |  Branch (159:9): [True: 0, False: 6.11M]
  ------------------
  160|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  161|       |
  162|       |    // Copy down every element above remove point
  163|  6.11M|    for (XMLSize_t index = removeAt; index < fCurCount-1; index++)
  ------------------
  |  Branch (163:38): [True: 0, False: 6.11M]
  ------------------
  164|      0|        fElemList[index] = fElemList[index+1];
  165|       |
  166|       |    // And bump down count
  167|  6.11M|    fCurCount--;
  168|  6.11M|}
_ZN11xercesc_3_213ValueVectorOfINS_15ContentSpecNode9NodeTypesEEC2EmPNS_13MemoryManagerEb:
   46|    108|{
   47|    108|    fElemList = (TElem*) fMemoryManager->allocate
   48|    108|    (
   49|    108|        fMaxCount * sizeof(TElem)
   50|    108|    ); //new TElem[fMaxCount];
   51|       |
   52|    108|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|    108|}
_ZN11xercesc_3_213ValueVectorOfINS_15ContentSpecNode9NodeTypesEED2Ev:
   75|    108|{
   76|    108|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 108]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|    108|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|    108|}
_ZN11xercesc_3_213ValueVectorOfINS_15ContentSpecNode9NodeTypesEE9elementAtEm:
  202|  46.8k|{
  203|  46.8k|    if (getAt >= fCurCount)
  ------------------
  |  Branch (203:9): [True: 0, False: 46.8k]
  ------------------
  204|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Vector_BadIndex, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  205|  46.8k|    return fElemList[getAt];
  206|  46.8k|}
_ZN11xercesc_3_213ValueVectorOfINS_15ContentSpecNode9NodeTypesEE10addElementERKS2_:
  121|  46.8k|{
  122|  46.8k|    ensureExtraCapacity(1);
  123|  46.8k|    fElemList[fCurCount++] = toAdd;
  124|  46.8k|}
_ZN11xercesc_3_213ValueVectorOfINS_15ContentSpecNode9NodeTypesEE19ensureExtraCapacityEm:
  229|  46.8k|{
  230|  46.8k|    XMLSize_t newMax = fCurCount + length;
  231|       |
  232|  46.8k|    if (newMax > fMaxCount)
  ------------------
  |  Branch (232:9): [True: 358, False: 46.5k]
  ------------------
  233|    358|    {
  234|       |        // Avoid too many reallocations by expanding by a percentage
  235|    358|        XMLSize_t minNewMax = (XMLSize_t)((double)fCurCount * 1.25);
  236|    358|        if (newMax < minNewMax)
  ------------------
  |  Branch (236:13): [True: 358, False: 0]
  ------------------
  237|    358|            newMax = minNewMax;
  238|       |
  239|    358|        TElem* newList = (TElem*) fMemoryManager->allocate
  240|    358|        (
  241|    358|            newMax * sizeof(TElem)
  242|    358|        ); //new TElem[newMax];
  243|   199k|        for (XMLSize_t index = 0; index < fCurCount; index++)
  ------------------
  |  Branch (243:35): [True: 199k, False: 358]
  ------------------
  244|   199k|            newList[index] = fElemList[index];
  245|       |
  246|    358|        fMemoryManager->deallocate(fElemList); //delete [] fElemList;
  247|    358|        fElemList = newList;
  248|    358|        fMaxCount = newMax;
  249|    358|    }
  250|  46.8k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ComplexTypeInfoEEC2EmPNS_13MemoryManagerEb:
   46|  8.51k|{
   47|  8.51k|    fElemList = (TElem*) fMemoryManager->allocate
   48|  8.51k|    (
   49|  8.51k|        fMaxCount * sizeof(TElem)
   50|  8.51k|    ); //new TElem[fMaxCount];
   51|       |
   52|  8.51k|    memset(fElemList, 0, fMaxCount * sizeof(TElem));
   53|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ComplexTypeInfoEED2Ev:
   75|  8.51k|{
   76|  8.51k|    if (fCallDestructor) {
  ------------------
  |  Branch (76:9): [True: 0, False: 8.51k]
  ------------------
   77|      0|        for (XMLSize_t index=fMaxCount; index > 0; index--)
  ------------------
  |  Branch (77:41): [True: 0, False: 0]
  ------------------
   78|      0|            fElemList[index-1].~TElem();
   79|      0|    }
   80|  8.51k|    fMemoryManager->deallocate(fElemList); //delete [] fElemList;
   81|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIPNS_15ComplexTypeInfoEE17removeAllElementsEv:
  171|  8.51k|{
  172|  8.51k|    fCurCount = 0;
  173|  8.51k|}
_ZN11xercesc_3_213ValueVectorOfIiE17removeAllElementsEv:
  171|  8.51k|{
  172|  8.51k|    fCurCount = 0;
  173|  8.51k|}

_ZN11xercesc_3_221XML256TableTranscoderD2Ev:
   35|     20|{
   36|       |    // We don't own the tables, we just reference them
   37|     20|}
_ZN11xercesc_3_221XML256TableTranscoder13transcodeFromEPKhmPDsmRmPh:
   50|     20|{
   51|       |    //
   52|       |    //  Calculate the max chars we can do here. Its the lesser of the
   53|       |    //  max output chars and the number of chars in the source.
   54|       |    //
   55|     20|    const XMLSize_t countToDo = srcCount < maxChars ? srcCount : maxChars;
  ------------------
  |  Branch (55:33): [True: 15, False: 5]
  ------------------
   56|       |
   57|       |    //
   58|       |    //  Loop through the count we have to do and map each char via the
   59|       |    //  lookup table.
   60|       |    //
   61|     20|    const XMLByte*  srcPtr = srcData;
   62|     20|    const XMLByte*  endPtr = (srcPtr + countToDo);
   63|     20|    XMLCh*          outPtr = toFill;
   64|   116k|    while (srcPtr < endPtr)
  ------------------
  |  Branch (64:12): [True: 116k, False: 20]
  ------------------
   65|   116k|    {
   66|   116k|        const XMLCh uniCh = fFromTable[*srcPtr++];
   67|   116k|        if (uniCh != 0xFFFF)
  ------------------
  |  Branch (67:13): [True: 116k, False: 0]
  ------------------
   68|   116k|        {
   69|   116k|            *outPtr++ = uniCh;
   70|   116k|            continue;
   71|   116k|        }
   72|   116k|    }
   73|       |
   74|       |
   75|       |    // Set the bytes eaten
   76|     20|    bytesEaten = countToDo;
   77|       |
   78|       |    // Set the character sizes to the fixed size
   79|     20|    memset(charSizes, 1, countToDo);
   80|       |
   81|       |    // Return the chars we transcoded
   82|     20|    return countToDo;
   83|     20|}
_ZN11xercesc_3_221XML256TableTranscoderC2EPKDsmS2_PKNS_15XMLTransService8TransRecEmPNS_13MemoryManagerE:
  173|     20|{
  174|     20|}

_ZN11xercesc_3_218XML88591TranscoderC2EPKDsmPNS_13MemoryManagerE:
   37|     68|{
   38|     68|}
_ZN11xercesc_3_218XML88591TranscoderD2Ev:
   42|     68|{
   43|     68|}
_ZN11xercesc_3_218XML88591Transcoder13transcodeFromEPKhmPDsmRmPh:
   56|    341|{
   57|       |    //
   58|       |    //  Calculate the max chars we can do here. Its the lesser of the
   59|       |    //  max output chars and the number of bytes in the source.
   60|       |    //
   61|    341|    const XMLSize_t countToDo = srcCount < maxChars ? srcCount : maxChars;
  ------------------
  |  Branch (61:33): [True: 99, False: 242]
  ------------------
   62|       |
   63|       |    //
   64|       |    //  Loop through the bytes to do and convert over each byte. Its just
   65|       |    //  a cast to the wide char type.
   66|       |    //
   67|    341|    const XMLByte*  srcPtr = srcData;
   68|    341|    XMLCh*          destPtr = toFill;
   69|    341|    const XMLByte*  srcEnd = srcPtr + countToDo;
   70|  4.12M|    while (srcPtr < srcEnd)
  ------------------
  |  Branch (70:12): [True: 4.12M, False: 341]
  ------------------
   71|  4.12M|        *destPtr++ = XMLCh(*srcPtr++);
   72|       |
   73|       |    // Set the bytes eaten, and set the char size array to the fixed size
   74|    341|    bytesEaten = countToDo;
   75|    341|    memset(charSizes, 1, countToDo);
   76|       |
   77|       |    // Return the chars we transcoded
   78|    341|    return countToDo;
   79|    341|}

_ZN11xercesc_3_218XMLASCIITranscoderC2EPKDsmPNS_13MemoryManagerE:
   37|     76|{
   38|     76|}
_ZN11xercesc_3_218XMLASCIITranscoderD2Ev:
   42|     76|{
   43|     76|}
_ZN11xercesc_3_218XMLASCIITranscoder13transcodeFromEPKhmPDsmRmPh:
   56|    433|{
   57|       |    //
   58|       |    //  Calculate the max chars we can do here. Its the lesser of the
   59|       |    //  max output chars and the source byte count.
   60|       |    //
   61|    433|    const XMLSize_t countToDo = srcCount < maxChars ? srcCount : maxChars;
  ------------------
  |  Branch (61:33): [True: 146, False: 287]
  ------------------
   62|       |
   63|       |    //
   64|       |    //  Now loop through that many source chars and just cast each one
   65|       |    //  over to the XMLCh format. Check each source that its really a
   66|       |    //  valid ASCI char.
   67|       |    //
   68|    433|    const XMLByte*  srcPtr = srcData;
   69|    433|    XMLCh*          outPtr = toFill;
   70|    433|    XMLSize_t       countDone = 0;
   71|  4.92M|    for (; countDone < countToDo; countDone++)
  ------------------
  |  Branch (71:12): [True: 4.92M, False: 382]
  ------------------
   72|  4.92M|    {
   73|       |        // Do the optimistic work up front
   74|  4.92M|        if (*srcPtr < 0x80)
  ------------------
  |  Branch (74:13): [True: 4.92M, False: 51]
  ------------------
   75|  4.92M|        {
   76|  4.92M|            *outPtr++ = XMLCh(*srcPtr++);
   77|  4.92M|            continue;
   78|  4.92M|        }
   79|       |
   80|       |        //
   81|       |        //  We got non source encoding char. If we got more than 32 chars,
   82|       |        //  the just break out. We'll come back here later to hit this again
   83|       |        //  and give an error much closer to the real source position.
   84|       |        //
   85|     51|        if (countDone > 32)
  ------------------
  |  Branch (85:13): [True: 26, False: 25]
  ------------------
   86|     26|            break;
   87|       |
   88|     25|        XMLCh tmpBuf[17];
   89|     25|        XMLString::binToText((unsigned int)*srcPtr, tmpBuf, 16, 16, getMemoryManager());
   90|     25|        ThrowXMLwithMemMgr2
  ------------------
  |  |  268|     25|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
   91|     51|        (
   92|     51|            TranscodingException
   93|     51|            , XMLExcepts::Trans_Unrepresentable
   94|     51|            , tmpBuf
   95|     51|            , getEncodingName()
   96|     51|            , getMemoryManager()
   97|     51|        );
   98|     51|    }
   99|       |
  100|       |    // Set the bytes we ate
  101|    408|    bytesEaten = countDone;
  102|       |
  103|       |    // Set the char sizes to the fixed size
  104|    408|    memset(charSizes, 1, countDone);
  105|       |
  106|       |    // Return the chars we transcoded
  107|    408|    return countDone;
  108|    433|}

_ZN11xercesc_3_213XMLBigDecimalC2EPKDsPNS_13MemoryManagerE:
   62|     32|{
   63|     32|    if ((!strValue) || (!*strValue))
  ------------------
  |  Branch (63:9): [True: 0, False: 32]
  |  Branch (63:24): [True: 0, False: 32]
  ------------------
   64|      0|        ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_emptyString, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   65|       |
   66|     32|    CleanupType cleanup(this, &XMLBigDecimal::cleanUp);
   67|       |
   68|     32|    try
   69|     32|    {
   70|     32|        fRawDataLen = XMLString::stringLen(strValue);
   71|     32|        fRawData = (XMLCh*) fMemoryManager->allocate
   72|     32|        (
   73|     32|            ((fRawDataLen*2) + 2) * sizeof(XMLCh) //fRawData and fIntVal
   74|     32|        );
   75|     32|        memcpy(fRawData, strValue, fRawDataLen * sizeof(XMLCh));
   76|     32|        fRawData[fRawDataLen] = chNull;
   77|     32|        fIntVal = fRawData + fRawDataLen + 1;
   78|     32|        parseDecimal(strValue, fIntVal, fSign, (int&) fTotalDigits, (int&) fScale, fMemoryManager);
   79|     32|    }
   80|     32|    catch(const OutOfMemoryException&)
   81|     32|    {
   82|      0|        cleanup.release();
   83|       |
   84|      0|        throw;
   85|      0|    }
   86|       |
   87|     32|    cleanup.release();
   88|     32|}
_ZN11xercesc_3_213XMLBigDecimalD2Ev:
   91|     16|{
   92|     16|    cleanUp();
   93|     16|}
_ZN11xercesc_3_213XMLBigDecimal7cleanUpEv:
   96|     16|{
   97|     16|    if (fRawData)
  ------------------
  |  Branch (97:9): [True: 16, False: 0]
  ------------------
   98|     16|        fMemoryManager->deallocate(fRawData); //XMLString::release(&fRawData);
   99|     16|}
_ZN11xercesc_3_213XMLBigDecimal12parseDecimalEPKDsPDsRiS4_S4_PNS_13MemoryManagerE:
  208|     32|{
  209|       |    //init
  210|     32|    retBuffer[0] = chNull;
  211|     32|    totalDigits = 0;
  212|     32|    fractDigits = 0;
  213|       |
  214|       |    // Strip leading white space, if any. 
  215|     32|    const XMLCh* startPtr = toParse;
  216|     32|    while (XMLChar1_0::isWhitespace(*startPtr))
  ------------------
  |  Branch (216:12): [True: 0, False: 32]
  ------------------
  217|      0|        startPtr++;
  218|       |
  219|       |    // If we hit the end, then return failure
  220|     32|    if (!*startPtr)
  ------------------
  |  Branch (220:9): [True: 0, False: 32]
  ------------------
  221|      0|        ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_WSString, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  222|       |
  223|       |    // Strip tailing white space, if any.
  224|     32|    const XMLCh* endPtr = toParse + XMLString::stringLen(toParse);
  225|     32|    while (XMLChar1_0::isWhitespace(*(endPtr - 1)))
  ------------------
  |  Branch (225:12): [True: 0, False: 32]
  ------------------
  226|      0|        endPtr--;
  227|       |
  228|       |    // '+' or '-' is allowed only at the first position
  229|       |    // and is NOT included in the return parsed string
  230|     32|    sign = 1;
  231|     32|    if (*startPtr == chDash)
  ------------------
  |  Branch (231:9): [True: 10, False: 22]
  ------------------
  232|     10|    {
  233|     10|        sign = -1;
  234|     10|        startPtr++;
  235|     10|        if (startPtr == endPtr)
  ------------------
  |  Branch (235:13): [True: 0, False: 10]
  ------------------
  236|      0|        {
  237|      0|            ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_Inv_chars, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  238|      0|        }
  239|     10|    }
  240|     22|    else if (*startPtr == chPlus)
  ------------------
  |  Branch (240:14): [True: 0, False: 22]
  ------------------
  241|      0|    {
  242|      0|        startPtr++;         
  243|      0|        if (startPtr == endPtr)
  ------------------
  |  Branch (243:13): [True: 0, False: 0]
  ------------------
  244|      0|        {
  245|      0|            ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_Inv_chars, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  246|      0|        }
  247|      0|    }
  248|       |
  249|       |    // Strip leading zeros
  250|     36|    while (*startPtr == chDigit_0)
  ------------------
  |  Branch (250:12): [True: 4, False: 32]
  ------------------
  251|      4|        startPtr++;
  252|       |
  253|       |    // containning zero, only zero, nothing but zero
  254|       |    // it is a zero, indeed
  255|     32|    if (startPtr >= endPtr)
  ------------------
  |  Branch (255:9): [True: 4, False: 28]
  ------------------
  256|      4|    {
  257|      4|        sign = 0;
  258|      4|        return;
  259|      4|    }
  260|       |
  261|     28|    XMLCh* retPtr = (XMLCh*) retBuffer;
  262|       |
  263|       |    // Scan data
  264|     28|    bool   dotSignFound = false;
  265|    256|    while (startPtr < endPtr)
  ------------------
  |  Branch (265:12): [True: 228, False: 28]
  ------------------
  266|    228|    {
  267|    228|        if (*startPtr == chPeriod)
  ------------------
  |  Branch (267:13): [True: 0, False: 228]
  ------------------
  268|      0|        {
  269|      0|            if (!dotSignFound)
  ------------------
  |  Branch (269:17): [True: 0, False: 0]
  ------------------
  270|      0|            {
  271|      0|                dotSignFound = true;
  272|      0|                fractDigits = (int)(endPtr - startPtr - 1);
  273|      0|                startPtr++;
  274|      0|                continue;
  275|      0|            }
  276|      0|            else  // '.' is allowed only once
  277|      0|                ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_2ManyDecPoint, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  278|      0|        }
  279|       |
  280|       |        // If not valid decimal digit, then an error
  281|    228|        if ((*startPtr < chDigit_0) || (*startPtr > chDigit_9))
  ------------------
  |  Branch (281:13): [True: 0, False: 228]
  |  Branch (281:40): [True: 0, False: 228]
  ------------------
  282|      0|            ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_Inv_chars, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  283|       |
  284|       |        // copy over
  285|    228|        *retPtr++ = *startPtr++;
  286|    228|        totalDigits++;
  287|    228|    }
  288|       |
  289|       |    /***
  290|       |    E2-44 totalDigits
  291|       |
  292|       |     ... by restricting it to numbers that are expressible as i x 10^-n
  293|       |     where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits. 
  294|       |
  295|       |        normalization: remove all trailing zero after the '.'
  296|       |                       and adjust the scaleValue as well.
  297|       |    ***/
  298|     28|    while ((fractDigits > 0) && (*(retPtr-1) == chDigit_0))          
  ------------------
  |  Branch (298:12): [True: 0, False: 28]
  |  Branch (298:33): [True: 0, False: 0]
  ------------------
  299|      0|    {
  300|      0|        retPtr--;
  301|      0|        fractDigits--;
  302|      0|        totalDigits--;
  303|      0|    }
  304|       |    // 0.0 got past the check for zero because of the decimal point, so we need to double check it here
  305|     28|    if(totalDigits==0)
  ------------------
  |  Branch (305:8): [True: 0, False: 28]
  ------------------
  306|      0|        sign = 0;
  307|       |
  308|     28|    *retPtr = chNull;   //terminated
  309|     28|    return;
  310|     28|}
_ZN11xercesc_3_213XMLBigDecimal13compareValuesEPKS0_S2_PNS_13MemoryManagerE:
  391|     46|{
  392|     46|    if ((!lValue) || (!rValue) )
  ------------------
  |  Branch (392:9): [True: 0, False: 46]
  |  Branch (392:22): [True: 0, False: 46]
  ------------------
  393|      0|        ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_null_ptr, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  394|       |        	
  395|     46|    return lValue->toCompare(*rValue);
  396|     46|}                                
_ZNK11xercesc_3_213XMLBigDecimal9toCompareERKS0_:
  406|     46|{
  407|       |    /***
  408|       |     * different sign
  409|       |     */
  410|     46|    int lSign = this->getSign();
  411|     46|    if (lSign != other.getSign())
  ------------------
  |  Branch (411:9): [True: 28, False: 18]
  ------------------
  412|     28|        return (lSign > other.getSign() ? 1 : -1);
  ------------------
  |  Branch (412:17): [True: 16, False: 12]
  ------------------
  413|       |
  414|       |    /***
  415|       |     * same sign, zero
  416|       |     */
  417|     18|    if (lSign == 0)    // optimization
  ------------------
  |  Branch (417:9): [True: 0, False: 18]
  ------------------
  418|      0|        return 0;
  419|       |
  420|       |    /***
  421|       |     * same sign, non-zero
  422|       |     */
  423|     18|    unsigned int lIntDigit = this->getTotalDigit() - this->getScale();
  424|     18|    unsigned int rIntDigit = other.getTotalDigit() - other.getScale();
  425|       |
  426|     18|    if (lIntDigit > rIntDigit)
  ------------------
  |  Branch (426:9): [True: 0, False: 18]
  ------------------
  427|      0|    {
  428|      0|        return 1 * lSign;
  429|      0|    }
  430|     18|    else if (lIntDigit < rIntDigit)
  ------------------
  |  Branch (430:14): [True: 18, False: 0]
  ------------------
  431|     18|    {
  432|     18|        return -1 * lSign;
  433|     18|    }
  434|      0|    else  // compare fraction
  435|      0|    {
  436|      0|        int res = XMLString::compareString
  437|      0|        ( this->getValue()
  438|      0|        , other.getValue()
  439|      0|        );
  440|       |
  441|      0|        if (res > 0)
  ------------------
  |  Branch (441:13): [True: 0, False: 0]
  ------------------
  442|      0|            return 1 * lSign;
  443|      0|        else if (res < 0)
  ------------------
  |  Branch (443:18): [True: 0, False: 0]
  ------------------
  444|      0|            return -1 * lSign;
  445|      0|        else
  446|      0|            return 0;
  447|      0|    }
  448|       |
  449|     18|}

_ZNK11xercesc_3_213XMLBigDecimal7getSignEv:
  165|    120|{
  166|    120|    return fSign;
  167|    120|}
_ZNK11xercesc_3_213XMLBigDecimal8getScaleEv:
  175|     52|{
  176|     52|    return fScale;
  177|     52|}
_ZNK11xercesc_3_213XMLBigDecimal13getTotalDigitEv:
  180|     36|{
  181|     36|    return fTotalDigits;
  182|     36|}
_ZNK11xercesc_3_213XMLBigDecimal10getRawDataEv:
  185|     16|{
  186|     16|    return fRawData;
  187|     16|}
_ZNK11xercesc_3_213XMLBigDecimal16getMemoryManagerEv:
  195|     46|{
  196|     46|    return fMemoryManager;
  197|     46|}

_ZN11xercesc_3_215XMLChTranscoderC2EPKDsmPNS_13MemoryManagerE:
   36|  16.8k|{
   37|  16.8k|}
_ZN11xercesc_3_215XMLChTranscoderD2Ev:
   41|  16.8k|{
   42|  16.8k|}
_ZN11xercesc_3_215XMLChTranscoder13transcodeFromEPKhmPDsmRmPh:
   55|  24.8k|{
   56|       |    //
   57|       |    //  Calculate the max chars we can do here. Its the lesser of the
   58|       |    //  max output chars and the number of chars in the source.
   59|       |    //
   60|  24.8k|    const XMLSize_t srcChars = srcCount / sizeof(XMLCh);
   61|  24.8k|    const XMLSize_t countToDo = srcChars < maxChars ? srcChars : maxChars;
  ------------------
  |  Branch (61:33): [True: 18.9k, False: 5.91k]
  ------------------
   62|       |
   63|       |    //
   64|       |    //  Copy over the count of chars that we precalculated. Notice we
   65|       |    //  convert char count to byte count here!!!
   66|       |    //
   67|  24.8k|    memcpy(toFill, srcData, countToDo * sizeof(XMLCh));
   68|       |
   69|       |    // Set the bytes eaten
   70|  24.8k|    bytesEaten = countToDo * sizeof(XMLCh);
   71|       |
   72|       |    // Set the character sizes to the fixed size
   73|  24.8k|    memset(charSizes, sizeof(XMLCh), countToDo);
   74|       |
   75|       |    // Return the chars we transcoded
   76|  24.8k|    return countToDo;
   77|  24.8k|}

_ZN11xercesc_3_210XMLChar1_014isPublicIdCharEDsDs:
  190|   578k|{
  191|   578k|    if (!toCheck2) {
  ------------------
  |  Branch (191:9): [True: 578k, False: 0]
  ------------------
  192|   578k|        const XMLCh* curTable = gPublicIdChars;
  193|       |
  194|       |        // Check the ranges
  195|  1.71M|        while (*curTable)
  ------------------
  |  Branch (195:16): [True: 1.71M, False: 20]
  ------------------
  196|  1.71M|        {
  197|       |            //
  198|       |            //  If the test char is less than the low range, then it's never
  199|       |            //  going to match any other range, so break out. But we have to
  200|       |            //  run up to the range terminator first.
  201|       |            //
  202|  1.71M|            if (toCheck < *curTable++)
  ------------------
  |  Branch (202:17): [True: 4.67k, False: 1.71M]
  ------------------
  203|  4.67k|            {
  204|  36.4k|                while (*curTable++)
  ------------------
  |  Branch (204:24): [True: 31.7k, False: 4.67k]
  ------------------
  205|  31.7k|                {
  206|       |                    // Purposefully empty, we are just running up the pointer
  207|  31.7k|                }
  208|  4.67k|                break;
  209|  4.67k|            }
  210|       |
  211|       |            // If it's less than or equal to the top of the range, then a match
  212|  1.71M|            if (toCheck <= *curTable++)
  ------------------
  |  Branch (212:17): [True: 573k, False: 1.14M]
  ------------------
  213|   573k|                return true;
  214|  1.71M|        }
  215|       |
  216|       |        // And now test against singles
  217|  14.7k|        while (*curTable)
  ------------------
  |  Branch (217:16): [True: 14.7k, False: 38]
  ------------------
  218|  14.7k|        {
  219|  14.7k|            if (toCheck == *curTable++)
  ------------------
  |  Branch (219:17): [True: 4.66k, False: 10.0k]
  ------------------
  220|  4.66k|                return true;
  221|  14.7k|        }
  222|     38|        return false;
  223|  4.69k|    }
  224|      0|    return false;
  225|   578k|}
_ZN11xercesc_3_210XMLChar1_114isPublicIdCharEDsDs:
 4687|  2.44k|{
 4688|  2.44k|    if (!toCheck2) {
  ------------------
  |  Branch (4688:9): [True: 2.44k, False: 0]
  ------------------
 4689|  2.44k|        const XMLCh* curTable = gPublicIdChars;
 4690|       |
 4691|       |        // Check the ranges
 4692|  5.23k|        while (*curTable)
  ------------------
  |  Branch (4692:16): [True: 5.22k, False: 14]
  ------------------
 4693|  5.22k|        {
 4694|       |            //
 4695|       |            //  If the test char is less than the low range, then it's never
 4696|       |            //  going to match any other range, so break out. But we have to
 4697|       |            //  run up to the range terminator first.
 4698|       |            //
 4699|  5.22k|            if (toCheck < *curTable++)
  ------------------
  |  Branch (4699:17): [True: 710, False: 4.51k]
  ------------------
 4700|    710|            {
 4701|  4.72k|                while (*curTable++)
  ------------------
  |  Branch (4701:24): [True: 4.01k, False: 710]
  ------------------
 4702|  4.01k|                {
 4703|       |                    // Purposefully empty, we are just running up the pointer
 4704|  4.01k|                }
 4705|    710|                break;
 4706|    710|            }
 4707|       |
 4708|       |            // If it's less than or equal to the top of the range, then a match
 4709|  4.51k|            if (toCheck <= *curTable++)
  ------------------
  |  Branch (4709:17): [True: 1.72k, False: 2.79k]
  ------------------
 4710|  1.72k|                return true;
 4711|  4.51k|        }
 4712|       |
 4713|       |        // And now test against singles
 4714|  1.98k|        while (*curTable)
  ------------------
  |  Branch (4714:16): [True: 1.94k, False: 34]
  ------------------
 4715|  1.94k|        {
 4716|  1.94k|            if (toCheck == *curTable++)
  ------------------
  |  Branch (4716:17): [True: 690, False: 1.25k]
  ------------------
 4717|    690|                return true;
 4718|  1.94k|        }
 4719|     34|        return false;
 4720|    724|    }
 4721|      0|    return false;
 4722|  2.44k|}

_ZN11xercesc_3_210XMLChar1_012isWhitespaceEDs:
  243|  8.82k|{
  244|  8.82k|    return ((fgCharCharsTable1_0[toCheck] & gWhitespaceCharMask) != 0);
  245|  8.82k|}

_ZN11xercesc_3_219XMLEBCDICTranscoderC2EPKDsmPNS_13MemoryManagerE:
  197|     10|{
  198|     10|}
_ZN11xercesc_3_219XMLEBCDICTranscoderD2Ev:
  202|     10|{
  203|     10|}

_ZN11xercesc_3_213XMLEnumeratorINS_12KVStringPairEEC2Ev:
   44|     20|    XMLEnumerator() {}
_ZN11xercesc_3_213XMLEnumeratorINS_12KVStringPairEED2Ev:
   35|     20|    virtual ~XMLEnumerator() {};
_ZN11xercesc_3_213XMLEnumeratorINS_10XMLRefInfoEEC2Ev:
   44|  1.42k|    XMLEnumerator() {}
_ZN11xercesc_3_213XMLEnumeratorINS_10XMLRefInfoEED2Ev:
   35|  1.42k|    virtual ~XMLEnumerator() {};
_ZN11xercesc_3_213XMLEnumeratorINS_12SchemaAttDefEEC2Ev:
   44|      1|    XMLEnumerator() {}
_ZN11xercesc_3_213XMLEnumeratorINS_9DTDAttDefEEC2Ev:
   44|  39.0k|    XMLEnumerator() {}
_ZN11xercesc_3_213XMLEnumeratorINS_9DTDAttDefEED2Ev:
   35|  39.0k|    virtual ~XMLEnumerator() {};
_ZN11xercesc_3_213XMLEnumeratorINS_14DTDElementDeclEEC2Ev:
   44|  4.22k|    XMLEnumerator() {}
_ZN11xercesc_3_213XMLEnumeratorINS_14DTDElementDeclEED2Ev:
   35|  4.22k|    virtual ~XMLEnumerator() {};
_ZN11xercesc_3_213XMLEnumeratorINS_13DTDEntityDeclEEC2Ev:
   44|  4.22k|    XMLEnumerator() {}
_ZN11xercesc_3_213XMLEnumeratorINS_13DTDEntityDeclEED2Ev:
   35|  4.22k|    virtual ~XMLEnumerator() {};

_ZN11xercesc_3_214XMLInitializer22initializeXMLExceptionEv:
   39|      1|{
   40|      1|    sMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgExceptDomain);
   41|       |
   42|      1|    if (!sMsgLoader)
  ------------------
  |  Branch (42:9): [True: 0, False: 1]
  ------------------
   43|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   44|      1|}
_ZN11xercesc_3_212XMLExceptionD2Ev:
   63|  2.95k|{
   64|  2.95k|    fMemoryManager->deallocate(fMsg);
   65|  2.95k|    fMemoryManager->deallocate(fSrcFile);
   66|  2.95k|}
_ZN11xercesc_3_212XMLExceptionC2EPKcmPNS_13MemoryManagerE:
  104|  2.95k|{
  105|  2.95k|    if (!memoryManager)
  ------------------
  |  Branch (105:9): [True: 0, False: 2.95k]
  ------------------
  106|      0|      fMemoryManager =
  107|      0|        XMLPlatformUtils::fgMemoryManager->getExceptionMemoryManager();
  108|  2.95k|    else
  109|  2.95k|      fMemoryManager = memoryManager->getExceptionMemoryManager();
  110|       |
  111|  2.95k|    fSrcFile = XMLString::replicate(srcFile, fMemoryManager);
  112|  2.95k|}
_ZN11xercesc_3_212XMLException14loadExceptTextENS_10XMLExcepts5CodesE:
  172|    350|{
  173|       |    // Store the error code
  174|    350|    fCode = toLoad;
  175|       |
  176|       |    // Load up the text into a local buffer
  177|    350|    const XMLSize_t msgSize = 2047;
  178|    350|    XMLCh errText[msgSize + 1];
  179|       |
  180|       |    // load the text
  181|    350|	if (!gGetMsgLoader().loadMsg(toLoad, errText, msgSize))
  ------------------
  |  Branch (181:6): [True: 0, False: 350]
  ------------------
  182|      0|	{
  183|      0|		fMsg = XMLString::replicate
  184|      0|        (
  185|      0|        XMLUni::fgDefErrMsg
  186|      0|            , fMemoryManager
  187|      0|        );
  188|      0|		return;
  189|      0|	}
  190|       |
  191|       |    // We got the text so replicate it into the message member
  192|    350|    fMsg = XMLString::replicate(errText, fMemoryManager);
  193|    350|}
_ZN11xercesc_3_212XMLException14loadExceptTextENS_10XMLExcepts5CodesEPKDsS4_S4_S4_:
  202|  2.31k|{
  203|       |    // Store the error code
  204|  2.31k|    fCode = toLoad;
  205|       |
  206|       |    // Load up the text into a local buffer
  207|  2.31k|    const XMLSize_t msgSize = 4095;
  208|  2.31k|    XMLCh errText[msgSize + 1];
  209|       |
  210|       |    // load the text
  211|  2.31k|	if (!gGetMsgLoader().loadMsg(toLoad, errText, msgSize, text1, text2, text3, text4, fMemoryManager))
  ------------------
  |  Branch (211:6): [True: 0, False: 2.31k]
  ------------------
  212|      0|	{
  213|      0|		fMsg = XMLString::replicate
  214|      0|        (
  215|      0|        XMLUni::fgDefErrMsg
  216|      0|            , fMemoryManager
  217|      0|        );
  218|      0|		return;
  219|      0|	}
  220|       |
  221|       |    // We got the text so replicate it into the message member
  222|  2.31k|    fMsg = XMLString::replicate(errText, fMemoryManager);
  223|  2.31k|}
_ZN11xercesc_3_212XMLException14loadExceptTextENS_10XMLExcepts5CodesEPKcS4_S4_S4_:
  232|    290|{
  233|       |    // Store the error code
  234|    290|    fCode = toLoad;
  235|       |
  236|       |    // Load up the text into a local buffer
  237|    290|    const XMLSize_t msgSize = 4095;
  238|    290|    XMLCh errText[msgSize + 1];
  239|       |
  240|       |    // load the text
  241|    290|	if (!gGetMsgLoader().loadMsg(toLoad, errText, msgSize, text1, text2, text3, text4, fMemoryManager))
  ------------------
  |  Branch (241:6): [True: 0, False: 290]
  ------------------
  242|      0|	{
  243|      0|		fMsg = XMLString::replicate
  244|      0|        (
  245|      0|        XMLUni::fgDefErrMsg
  246|      0|            , fMemoryManager
  247|      0|        );
  248|      0|		return;
  249|      0|	}
  250|       |
  251|       |    // We got the text so replicate it into the message member
  252|    290|    fMsg = XMLString::replicate(errText, fMemoryManager);
  253|    290|}
XMLException.cpp:_ZN11xercesc_3_2L13gGetMsgLoaderEv:
   55|  2.95k|{
   56|  2.95k|    return *sMsgLoader;
   57|  2.95k|}

_ZNK11xercesc_3_212XMLException7getCodeEv:
  141|  2.95k|{
  142|  2.95k|    return fCode;
  143|  2.95k|}
_ZNK11xercesc_3_212XMLException10getMessageEv:
  146|  2.95k|{
  147|  2.95k|    return fMsg;
  148|  2.95k|}
_ZNK11xercesc_3_212XMLException12getErrorTypeEv:
  163|  5.90k|{
  164|  5.90k|   if ((fCode >= XMLExcepts::W_LowBounds) && (fCode <= XMLExcepts::W_HighBounds))
  ------------------
  |  Branch (164:8): [True: 5.90k, False: 0]
  |  Branch (164:46): [True: 0, False: 5.90k]
  ------------------
  165|      0|       return XMLErrorReporter::ErrType_Warning;
  166|  5.90k|   else if ((fCode >= XMLExcepts::F_LowBounds) && (fCode <= XMLExcepts::F_HighBounds))
  ------------------
  |  Branch (166:13): [True: 5.90k, False: 0]
  |  Branch (166:51): [True: 5.90k, False: 0]
  ------------------
  167|  5.90k|        return XMLErrorReporter::ErrType_Fatal;
  168|      0|   else if ((fCode >= XMLExcepts::E_LowBounds) && (fCode <= XMLExcepts::E_HighBounds))
  ------------------
  |  Branch (168:13): [True: 0, False: 0]
  |  Branch (168:51): [True: 0, False: 0]
  ------------------
  169|      0|        return XMLErrorReporter::ErrType_Error;
  170|      0|   return XMLErrorReporter::ErrTypes_Unknown;
  171|  5.90k|}
_ZN11xercesc_3_225XMLPlatformUtilsExceptionC2EPKcmNS_10XMLExcepts5CodesEPNS_13MemoryManagerE:
  188|     10|    { \
  189|     10|        loadExceptText(toThrow); \
  190|     10|    } \
_ZN11xercesc_3_216RuntimeExceptionC2EPKcmNS_10XMLExcepts5CodesEPKDsS6_S6_S6_PNS_13MemoryManagerE:
  207|  2.09k|    { \
  208|  2.09k|        loadExceptText(toThrow, text1, text2, text3, text4); \
  209|  2.09k|    } \
_ZN11xercesc_3_220TranscodingExceptionC2EPKcmNS_10XMLExcepts5CodesEPNS_13MemoryManagerE:
  188|    240|    { \
  189|    240|        loadExceptText(toThrow); \
  190|    240|    } \
_ZN11xercesc_3_220TranscodingExceptionC2EPKcmNS_10XMLExcepts5CodesEPKDsS6_S6_S6_PNS_13MemoryManagerE:
  207|    121|    { \
  208|    121|        loadExceptText(toThrow, text1, text2, text3, text4); \
  209|    121|    } \
_ZN11xercesc_3_221MalformedURLExceptionC2EPKcmNS_10XMLExcepts5CodesEPNS_13MemoryManagerE:
  188|     11|    { \
  189|     11|        loadExceptText(toThrow); \
  190|     11|    } \
_ZN11xercesc_3_220NetAccessorExceptionC2EPKcmNS_10XMLExcepts5CodesEPKDsS6_S6_S6_PNS_13MemoryManagerE:
  207|     93|    { \
  208|     93|        loadExceptText(toThrow, text1, text2, text3, text4); \
  209|     93|    } \
_ZN11xercesc_3_222UTFDataFormatExceptionC2EPKcmNS_10XMLExcepts5CodesES2_S2_S2_S2_PNS_13MemoryManagerE:
  220|    290|    { \
  221|    290|        loadExceptText(toThrow, text1, text2, text3, text4); \
  222|    290|    } \
_ZN11xercesc_3_222UnexpectedEOFExceptionC2EPKcmNS_10XMLExcepts5CodesEPNS_13MemoryManagerE:
  188|     89|    { \
  189|     89|        loadExceptText(toThrow); \
  190|     89|    } \

_ZN11xercesc_3_210XMLFileMgrC2Ev:
   37|      1|        XMLFileMgr() {}

_ZN11xercesc_3_220XMLIBM1047TranscoderC2EPKDsmPNS_13MemoryManagerE:
  197|      1|{
  198|      1|}
_ZN11xercesc_3_220XMLIBM1047TranscoderD2Ev:
  202|      1|{
  203|      1|}

_ZN11xercesc_3_220XMLIBM1140TranscoderC2EPKDsmPNS_13MemoryManagerE:
  198|      9|{
  199|      9|}
_ZN11xercesc_3_220XMLIBM1140TranscoderD2Ev:
  203|      9|{
  204|      9|}

_ZN11xercesc_3_214XMLInitializer20initializeStaticDataEv:
   35|      1|{
   36|      1|    try
   37|      1|    {
   38|       |        // Note that in some cases the order of initialization can be
   39|       |        // important.
   40|       |        //
   41|       |
   42|       |        // Core
   43|       |        //
   44|      1|        initializeEncodingValidator();
   45|      1|        initializeXMLException();
   46|      1|        initializeXMLScanner();
   47|      1|        initializeXMLValidator();
   48|       |
   49|       |        // Regex
   50|       |        //
   51|      1|        initializeRangeTokenMap();
   52|      1|        initializeRegularExpression();
   53|       |
   54|       |        // DTD
   55|       |        //
   56|      1|        initializeDTDGrammar();
   57|       |
   58|       |        // Schema
   59|       |        //
   60|      1|        initializeXSDErrorReporter();
   61|      1|        initializeDatatypeValidatorFactory();
   62|      1|        initializeGeneralAttributeCheck();
   63|      1|        initializeXSValue();
   64|      1|        initializeComplexTypeInfo();
   65|       |
   66|       |        // DOM
   67|       |        //
   68|      1|        initializeDOMImplementationRegistry();
   69|      1|        initializeDOMImplementationImpl();
   70|      1|        initializeDOMDocumentTypeImpl();
   71|      1|        initializeDOMNodeListImpl();
   72|      1|        initializeDOMNormalizer();
   73|       |
   74|       |        // XInclude
   75|       |        //
   76|      1|        initializeXInclude();
   77|      1|	}
   78|      1|    catch(...) {
   79|      0|        XMLPlatformUtils::panic(PanicHandler::Panic_AllStaticInitErr);
   80|      0|    }
   81|      1|}

_ZNK11xercesc_3_210XMLInteger8intValueEv:
   76|  63.8M|{
   77|  63.8M|    return fData;
   78|  63.8M|}
_ZN11xercesc_3_210XMLIntegerC2Ei:
   68|  4.31M|{
   69|  4.31M|}
_ZN11xercesc_3_210XMLIntegerD2Ev:
   72|  4.31M|{
   73|  4.31M|}

_ZN11xercesc_3_212XMLMsgLoader9setLocaleEPKc:
   47|      1|{
   48|       |    /***
   49|       |     * Release the current setting's memory, if any
   50|       |     ***/
   51|      1|    if (fLocale)
  ------------------
  |  Branch (51:9): [True: 0, False: 1]
  ------------------
   52|      0|    {
   53|      0|        XMLPlatformUtils::fgMemoryManager->deallocate(fLocale);//delete [] fLocale;
   54|      0|        fLocale = 0;
   55|      0|    }
   56|       |
   57|       |    /***
   58|       |     *  
   59|       |     *  REVISIT: later we may do locale format checking
   60|       |     * 
   61|       |     *           refer to phttp://oss.software.ibm.com/icu/userguide/locale.html
   62|       |     *           for details.
   63|       |     */
   64|      1|    if (localeToAdopt && (strlen(localeToAdopt) == 2 || (strlen(localeToAdopt) > 3 && localeToAdopt[2]=='_')))
  ------------------
  |  Branch (64:9): [True: 1, False: 0]
  |  Branch (64:27): [True: 0, False: 1]
  |  Branch (64:58): [True: 1, False: 0]
  |  Branch (64:87): [True: 1, False: 0]
  ------------------
   65|      1|    {
   66|      1|        fLocale   = XMLString::replicate(localeToAdopt, XMLPlatformUtils::fgMemoryManager);                   
   67|      1|    }
   68|       |
   69|      1|}
_ZN11xercesc_3_212XMLMsgLoader10setNLSHomeEPKc:
   82|      1|{
   83|       |    /***
   84|       |     * Release the current setting's memory, if any
   85|       |     ***/
   86|      1|    if (fPath)
  ------------------
  |  Branch (86:9): [True: 0, False: 1]
  ------------------
   87|      0|    {
   88|      0|        XMLPlatformUtils::fgMemoryManager->deallocate(fPath);//delete [] fPath;
   89|      0|        fPath = 0;
   90|      0|    }
   91|       |
   92|      1|    if (nlsHomeToAdopt)
  ------------------
  |  Branch (92:9): [True: 0, False: 1]
  ------------------
   93|      0|    {
   94|      0|        fPath = XMLString::replicate(nlsHomeToAdopt, XMLPlatformUtils::fgMemoryManager);
   95|      0|    }
   96|       |
   97|      1|}

_ZN11xercesc_3_212XMLMsgLoaderC2Ev:
  177|      8|{
  178|      8|}

_ZN11xercesc_3_211XMLMutexMgrC2Ev:
   36|      1|        XMLMutexMgr() {}

_ZN11xercesc_3_214XMLNetAccessorC2Ev:
  123|      1|    {
  124|      1|    }

_ZN11xercesc_3_29XMLNumberC2Ev:
   38|     32|{}
_ZN11xercesc_3_29XMLNumberD2Ev:
   46|     16|{}

_ZN11xercesc_3_29XMLString14compareNStringEPKcS2_m:
  334|  17.0k|{
  335|       |    // Watch for pathological secenario
  336|  17.0k|    if (!count)
  ------------------
  |  Branch (336:9): [True: 0, False: 17.0k]
  ------------------
  337|      0|        return 0;
  338|       |
  339|  17.0k|    return strncmp(str1, str2, count);
  340|  17.0k|}
_ZN11xercesc_3_29XMLString3cutEPDsm:
  370|     85|{
  371|       |    #if defined(XML_DEBUG)
  372|       |    if (count > stringLen(toCutFrom))
  373|       |    {
  374|       |        // <TBD> This is bad of course
  375|       |    }
  376|       |    #endif
  377|       |
  378|       |    // If count is zero, then nothing to do
  379|     85|    if (!count)
  ------------------
  |  Branch (379:9): [True: 0, False: 85]
  ------------------
  380|      0|        return;
  381|       |
  382|     85|    XMLCh* targetPtr = toCutFrom;
  383|     85|    XMLCh* srcPtr = toCutFrom + count;
  384|  95.0k|    while (*srcPtr)
  ------------------
  |  Branch (384:12): [True: 94.9k, False: 85]
  ------------------
  385|  94.9k|        *targetPtr++ = *srcPtr++;
  386|       |
  387|       |    // Cap it off at the new end
  388|     85|    *targetPtr = 0;
  389|     85|}
_ZN11xercesc_3_29XMLString13replaceTokensEPDsmPKDsS3_S3_S3_PNS_13MemoryManagerE:
  486|  2.60k|{
  487|       |    //
  488|       |    //  We have to build the string back into the source string, so allocate
  489|       |    //  a temp string and copy the orignal text to it. We'll then treat the
  490|       |    //  incoming buffer as a target buffer. Put a janitor on it to make sure
  491|       |    //  it gets cleaned up.
  492|       |    //
  493|  2.60k|    XMLCh* orgText = replicate(errText, manager);
  494|  2.60k|    ArrayJanitor<XMLCh> janText(orgText, manager);
  495|       |
  496|  2.60k|    XMLCh* pszSrc = orgText;
  497|  2.60k|    XMLSize_t curOutInd = 0;
  498|       |
  499|  5.74k|    while (*pszSrc && (curOutInd < maxChars))
  ------------------
  |  Branch (499:12): [True: 5.74k, False: 0]
  |  Branch (499:23): [True: 5.70k, False: 40]
  ------------------
  500|  5.70k|    {
  501|       |        //
  502|       |        //  Loop until we see a { character. Until we do, just copy chars
  503|       |        //  from src to target, being sure not to overrun the output buffer.
  504|       |        //
  505|  90.6k|        while ((*pszSrc != chOpenCurly) && (curOutInd < maxChars))
  ------------------
  |  Branch (505:16): [True: 87.5k, False: 3.14k]
  |  Branch (505:44): [True: 87.5k, False: 1]
  ------------------
  506|  87.5k|        {
  507|  87.5k|            if (!*pszSrc)
  ------------------
  |  Branch (507:17): [True: 2.56k, False: 84.9k]
  ------------------
  508|  2.56k|                break;
  509|  84.9k|            errText[curOutInd++] = *pszSrc++;
  510|  84.9k|        }
  511|       |
  512|       |        // If we did not find a curly, then we are done
  513|  5.70k|        if (*pszSrc != chOpenCurly)
  ------------------
  |  Branch (513:13): [True: 2.56k, False: 3.14k]
  ------------------
  514|  2.56k|            break;
  515|       |
  516|       |        //
  517|       |        //  Probe this one to see if it matches our pattern of {x}. If not
  518|       |        //  then copy over those chars and go back to the first loop.
  519|       |        //
  520|  3.14k|        if ((*(pszSrc+1) >= chDigit_0)
  ------------------
  |  Branch (520:13): [True: 3.14k, False: 0]
  ------------------
  521|  3.14k|        &&  (*(pszSrc+1) <= chDigit_3)
  ------------------
  |  Branch (521:13): [True: 3.14k, False: 0]
  ------------------
  522|  3.14k|        &&  (*(pszSrc+2) == chCloseCurly))
  ------------------
  |  Branch (522:13): [True: 3.14k, False: 0]
  ------------------
  523|  3.14k|        {
  524|       |            //
  525|       |            //  Its one of our guys, so move the source pointer up past the
  526|       |            //  token we are replacing. First though get out the token number
  527|       |            //  character.
  528|       |            //
  529|  3.14k|            XMLCh tokCh = *(pszSrc+1);
  530|  3.14k|            pszSrc += 3;
  531|       |
  532|       |            // Now copy over the replacement text
  533|  3.14k|            const XMLCh* repText = 0;
  534|  3.14k|            if (tokCh == chDigit_0)
  ------------------
  |  Branch (534:17): [True: 2.60k, False: 546]
  ------------------
  535|  2.60k|                repText = text1;
  536|    546|            else if (tokCh == chDigit_1)
  ------------------
  |  Branch (536:22): [True: 315, False: 231]
  ------------------
  537|    315|                repText = text2;
  538|    231|            else if (tokCh == chDigit_2)
  ------------------
  |  Branch (538:22): [True: 231, False: 0]
  ------------------
  539|    231|                repText = text3;
  540|      0|            else if (tokCh == chDigit_3)
  ------------------
  |  Branch (540:22): [True: 0, False: 0]
  ------------------
  541|      0|                repText = text4;
  542|       |
  543|       |            // If this one is null, copy over a null string
  544|  3.14k|            if (!repText)
  ------------------
  |  Branch (544:17): [True: 0, False: 3.14k]
  ------------------
  545|      0|                repText = gNullStr;
  546|       |
  547|   236k|            while (*repText && (curOutInd < maxChars))
  ------------------
  |  Branch (547:20): [True: 233k, False: 3.10k]
  |  Branch (547:32): [True: 233k, False: 40]
  ------------------
  548|   233k|                errText[curOutInd++] = *repText++;
  549|  3.14k|        }
  550|      0|         else
  551|      0|        {
  552|       |            // Escape the curly brace character and continue
  553|      0|            errText[curOutInd++] = *pszSrc++;
  554|      0|        }
  555|  3.14k|    }
  556|       |
  557|       |    // Copy over a null terminator
  558|  2.60k|    errText[curOutInd] = 0;
  559|       |
  560|       |    // And return the count of chars we output
  561|  2.60k|    return curOutInd;
  562|  2.60k|}
_ZN11xercesc_3_29XMLString9replicateEPKcPNS_13MemoryManagerE:
  567|  2.95k|{
  568|       |    // If a null string, return a null string
  569|  2.95k|    if (!toRep)
  ------------------
  |  Branch (569:9): [True: 0, False: 2.95k]
  ------------------
  570|      0|        return 0;
  571|       |
  572|       |    //
  573|       |    //  Get the len of the source and allocate a new buffer. Make sure to
  574|       |    //  account for the nul terminator.
  575|       |    //
  576|  2.95k|    const XMLSize_t srcLen = strlen(toRep);
  577|  2.95k|    char* ret = (char*) manager->allocate((srcLen+1) * sizeof(char)); //new char[srcLen+1];
  578|       |
  579|       |    // Copy over the text, adjusting for the size of a char
  580|  2.95k|    memcpy(ret, toRep, (srcLen+1) * sizeof(char));
  581|  2.95k|    return ret;
  582|  2.95k|}
_ZN11xercesc_3_29XMLString9transcodeEPKDsPNS_13MemoryManagerE:
  605|  9.87k|{
  606|  9.87k|    return gTranscoder->transcode(toTranscode, manager);
  607|  9.87k|}
_ZN11xercesc_3_29XMLString9transcodeEPKcPNS_13MemoryManagerE:
  620|  9.32k|{
  621|  9.32k|    return gTranscoder->transcode(toTranscode, manager);
  622|  9.32k|}
_ZN11xercesc_3_29XMLString14isValidEncNameEPKDs:
  743|  7.65k|{
  744|  7.65k|	if (name == 0 || *name == 0)
  ------------------
  |  Branch (744:6): [True: 0, False: 7.65k]
  |  Branch (744:19): [True: 0, False: 7.65k]
  ------------------
  745|      0|        return false;
  746|       |
  747|  7.65k|    const XMLCh* tempName = name;
  748|  7.65k|    XMLCh firstChar = *tempName++;
  749|       |
  750|  7.65k|    if (!isAlpha(firstChar))
  ------------------
  |  Branch (750:9): [True: 4, False: 7.64k]
  ------------------
  751|      4|        return false;
  752|       |
  753|   168k|    while(*tempName)
  ------------------
  |  Branch (753:11): [True: 161k, False: 7.64k]
  ------------------
  754|   161k|    {
  755|   161k|        if (( !isAlpha(*tempName))       &&
  ------------------
  |  Branch (755:13): [True: 11.6k, False: 149k]
  ------------------
  756|   161k|            ( !isDigit(*tempName))       &&
  ------------------
  |  Branch (756:13): [True: 979, False: 10.6k]
  ------------------
  757|   161k|            ( *tempName != chPeriod)     &&
  ------------------
  |  Branch (757:13): [True: 979, False: 0]
  ------------------
  758|   161k|            ( *tempName != chUnderscore) &&
  ------------------
  |  Branch (758:13): [True: 866, False: 113]
  ------------------
  759|   161k|            ( *tempName != chDash)        )
  ------------------
  |  Branch (759:13): [True: 0, False: 866]
  ------------------
  760|      0|            return false;
  761|       |
  762|   161k|        tempName++;
  763|   161k|    }
  764|       |
  765|  7.64k|    return true;
  766|  7.64k|}
_ZN11xercesc_3_29XMLString7isAlphaEDs:
  769|  1.14M|{
  770|  1.14M|    if ((( theChar >= chLatin_a ) && ( theChar <= chLatin_z )) ||
  ------------------
  |  Branch (770:10): [True: 55.9k, False: 1.08M]
  |  Branch (770:38): [True: 55.8k, False: 135]
  ------------------
  771|  1.14M|        (( theChar >= chLatin_A ) && ( theChar <= chLatin_Z )) )
  ------------------
  |  Branch (771:10): [True: 864k, False: 223k]
  |  Branch (771:38): [True: 797k, False: 67.3k]
  ------------------
  772|   853k|        return true;
  773|       |
  774|   290k|    return false;
  775|  1.14M|}
_ZN11xercesc_3_29XMLString7isDigitEDs:
  778|   292k|{
  779|   292k|    if (( theChar >= chDigit_0 ) && ( theChar <= chDigit_9 ))
  ------------------
  |  Branch (779:9): [True: 284k, False: 8.29k]
  |  Branch (779:37): [True: 212k, False: 71.3k]
  ------------------
  780|   212k|        return true;
  781|       |
  782|  79.6k|    return false;
  783|   292k|}
_ZN11xercesc_3_29XMLString10isAlphaNumEDs:
  786|   975k|{
  787|   975k|    return (isAlpha(theChar) || isDigit(theChar));
  ------------------
  |  Branch (787:13): [True: 695k, False: 279k]
  |  Branch (787:33): [True: 201k, False: 77.5k]
  ------------------
  788|   975k|}
_ZN11xercesc_3_29XMLString5isHexEDs:
  791|  1.49k|{
  792|  1.49k|	return (isDigit(theChar) ||
  ------------------
  |  Branch (792:10): [True: 435, False: 1.06k]
  ------------------
  793|  1.49k|			(theChar >= chLatin_a && theChar <= chLatin_f) ||
  ------------------
  |  Branch (793:5): [True: 149, False: 912]
  |  Branch (793:29): [True: 99, False: 50]
  ------------------
  794|  1.49k|			(theChar >= chLatin_A && theChar <= chLatin_F));
  ------------------
  |  Branch (794:5): [True: 933, False: 29]
  |  Branch (794:29): [True: 873, False: 60]
  ------------------
  795|  1.49k|}
_ZN11xercesc_3_29XMLString9binToTextEmPDsmjPNS_13MemoryManagerE:
  897|    349|{
  898|    349|    static const XMLCh digitList[16] =
  899|    349|    {
  900|    349|            chDigit_0, chDigit_1, chDigit_2, chDigit_3, chDigit_4, chDigit_5
  901|    349|        ,   chDigit_6, chDigit_7, chDigit_8, chDigit_9, chLatin_A, chLatin_B
  902|    349|        ,   chLatin_C, chLatin_D, chLatin_E, chLatin_F
  903|    349|    };
  904|       |
  905|    349|    if (!maxChars)
  ------------------
  |  Branch (905:9): [True: 0, False: 349]
  ------------------
  906|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Str_ZeroSizedTargetBuf, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  907|       |
  908|       |    // Handle special case
  909|    349|    if (!toFormat)
  ------------------
  |  Branch (909:9): [True: 10, False: 339]
  ------------------
  910|     10|    {
  911|     10|        toFill[0] = chDigit_0;
  912|     10|        toFill[1] = chNull;
  913|     10|        return;
  914|     10|    }
  915|       |
  916|       |    // This is used to fill the temp buffer
  917|    339|    XMLSize_t tmpIndex = 0;
  918|       |
  919|       |    // A copy of the conversion value that we can modify
  920|    339|    unsigned long tmpVal = toFormat;
  921|       |
  922|       |    //
  923|       |    //  Convert into a temp buffer that we know is large enough. This avoids
  924|       |    //  having to check for overflow in the inner loops, and we have to flip
  925|       |    //  the resulting sring anyway.
  926|       |    //
  927|    339|    XMLCh   tmpBuf[128];
  928|       |
  929|       |    //
  930|       |    //  For each radix, do the optimal thing. For bin and hex, we can special
  931|       |    //  case them and do shift and mask oriented stuff. For oct and decimal
  932|       |    //  there isn't much to do but bull through it with divides.
  933|       |    //
  934|    339|    if (radix == 2)
  ------------------
  |  Branch (934:9): [True: 0, False: 339]
  ------------------
  935|      0|    {
  936|      0|        while (tmpVal)
  ------------------
  |  Branch (936:16): [True: 0, False: 0]
  ------------------
  937|      0|        {
  938|      0|            if (tmpVal & 0x1UL)
  ------------------
  |  Branch (938:17): [True: 0, False: 0]
  ------------------
  939|      0|                tmpBuf[tmpIndex++] = chDigit_1;
  940|      0|            else
  941|      0|                tmpBuf[tmpIndex++] = chDigit_0;
  942|      0|            tmpVal >>= 1;
  943|      0|        }
  944|      0|    }
  945|    339|     else if (radix == 16)
  ------------------
  |  Branch (945:15): [True: 234, False: 105]
  ------------------
  946|    234|    {
  947|    746|        while (tmpVal)
  ------------------
  |  Branch (947:16): [True: 512, False: 234]
  ------------------
  948|    512|        {
  949|    512|            const unsigned long charInd = (tmpVal & 0xFUL);
  950|    512|            tmpBuf[tmpIndex++] = digitList[charInd];
  951|    512|            tmpVal >>= 4;
  952|    512|        }
  953|    234|    }
  954|    105|     else if ((radix == 8) || (radix == 10))
  ------------------
  |  Branch (954:15): [True: 0, False: 105]
  |  Branch (954:31): [True: 105, False: 0]
  ------------------
  955|    105|    {
  956|  1.05k|        while (tmpVal)
  ------------------
  |  Branch (956:16): [True: 953, False: 105]
  ------------------
  957|    953|        {
  958|    953|            const unsigned long charInd = (tmpVal % radix);
  959|    953|            tmpBuf[tmpIndex++] = digitList[charInd];
  960|    953|            tmpVal /= radix;
  961|    953|        }
  962|    105|    }
  963|      0|     else
  964|      0|    {
  965|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Str_UnknownRadix, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  966|      0|    }
  967|       |
  968|       |    // See if have enough room in the caller's buffer
  969|    339|    if (tmpIndex > maxChars)
  ------------------
  |  Branch (969:9): [True: 0, False: 339]
  ------------------
  970|      0|    {
  971|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Str_TargetBufTooSmall, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  972|      0|    }
  973|       |
  974|       |    // Reverse the tmp buffer into the caller's buffer
  975|    339|    XMLSize_t outIndex = 0;
  976|  1.80k|    for (; tmpIndex > 0; tmpIndex--)
  ------------------
  |  Branch (976:12): [True: 1.46k, False: 339]
  ------------------
  977|  1.46k|        toFill[outIndex++] = tmpBuf[tmpIndex-1];
  978|       |
  979|       |    // And cap off the caller's buffer
  980|    339|    toFill[outIndex] = chNull;
  981|    339|}
_ZN11xercesc_3_29XMLString9binToTextEjPDsmjPNS_13MemoryManagerE:
  988|    130|{
  989|       |    // Just call the unsigned long version
  990|    130|    binToText((unsigned long)toFormat, toFill, maxChars, radix, manager);
  991|    130|}
_ZN11xercesc_3_29XMLString9binToTextElPDsmjPNS_13MemoryManagerE:
  998|    219|{
  999|       |    //
 1000|       |    //  If its negative, then put a negative sign into the output and flip
 1001|       |    //  the sign of the local temp value.
 1002|       |    //
 1003|    219|    XMLSize_t startInd = 0;
 1004|    219|    unsigned long actualVal;
 1005|    219|    if (toFormat < 0)
  ------------------
  |  Branch (1005:9): [True: 0, False: 219]
  ------------------
 1006|      0|    {
 1007|      0|        toFill[0] = chDash;
 1008|      0|        startInd++;
 1009|       |        // Signed integers can represent one extra negative value
 1010|       |        // compared to the positive values. If we simply do (v * -1)
 1011|       |        // we will overflow on that extra value.
 1012|       |        //
 1013|      0|        long v = toFormat;
 1014|      0|        v++;
 1015|      0|        actualVal = (unsigned long)(v * -1);
 1016|      0|        actualVal++;
 1017|      0|    }
 1018|    219|     else
 1019|    219|    {
 1020|    219|        actualVal = (unsigned long)(toFormat);
 1021|    219|    }
 1022|       |
 1023|       |    // And now call the unsigned long version
 1024|    219|    binToText(actualVal, &toFill[startInd], maxChars, radix, manager);
 1025|    219|}
_ZN11xercesc_3_29XMLString9binToTextEiPDsmjPNS_13MemoryManagerE:
 1032|    219|{
 1033|       |    // Just call the long version
 1034|    219|    binToText((long)toFormat, toFill, maxChars, radix, manager);
 1035|    219|}
_ZN11xercesc_3_29XMLString9catStringEPDsPKDs:
 1038|    150|{
 1039|       |    // Get the starting point for the cat on the target XMLString
 1040|    150|    XMLSize_t index = stringLen(target);
 1041|       |
 1042|       |    // While the source is not zero, add them to target and bump
 1043|    150|    const XMLCh* pszTmp = src;
 1044|    751|    while (*pszTmp)
  ------------------
  |  Branch (1044:12): [True: 601, False: 150]
  ------------------
 1045|    601|        target[index++] = *pszTmp++;
 1046|       |
 1047|       |    // Cap off the target where we ended
 1048|    150|    target[index] = chNull;
 1049|    150|}
_ZN11xercesc_3_29XMLString19compareIStringASCIIEPKDsS2_:
 1061|    727|{
 1062|    727|    const XMLCh* psz1 = str1;
 1063|    727|    const XMLCh* psz2 = str2;
 1064|       |
 1065|    727|    if (psz1 == 0 || psz2 == 0) {
  ------------------
  |  Branch (1065:9): [True: 0, False: 727]
  |  Branch (1065:22): [True: 0, False: 727]
  ------------------
 1066|       |
 1067|      0|        if (psz1 == 0) {
  ------------------
  |  Branch (1067:13): [True: 0, False: 0]
  ------------------
 1068|      0|            return 0 - (int)XMLString::stringLen(psz2);
 1069|      0|        }
 1070|      0|		else if (psz2 == 0) {
  ------------------
  |  Branch (1070:12): [True: 0, False: 0]
  ------------------
 1071|      0|            return (int)XMLString::stringLen(psz1);
 1072|      0|        }
 1073|      0|    }
 1074|       |
 1075|    727|    XMLCh ch1;
 1076|    727|    XMLCh ch2;
 1077|       |
 1078|  1.97k|    for (;;) {
 1079|  1.97k|        if (*psz1 >= chLatin_A && *psz1 <= chLatin_Z)
  ------------------
  |  Branch (1079:13): [True: 1.71k, False: 260]
  |  Branch (1079:35): [True: 68, False: 1.64k]
  ------------------
 1080|     68|            ch1 = *psz1 - chLatin_A + chLatin_a;
 1081|  1.90k|        else
 1082|  1.90k|            ch1 = *psz1;
 1083|  1.97k|        if (*psz2 >= chLatin_A && *psz2 <= chLatin_Z)
  ------------------
  |  Branch (1083:13): [True: 1.69k, False: 281]
  |  Branch (1083:35): [True: 1, False: 1.69k]
  ------------------
 1084|      1|            ch2 = *psz2 - chLatin_A + chLatin_a;
 1085|  1.97k|        else
 1086|  1.97k|            ch2 = *psz2;
 1087|       |
 1088|       |        // If an inequality, then return difference
 1089|  1.97k|        if (ch1 != ch2)
  ------------------
  |  Branch (1089:13): [True: 504, False: 1.46k]
  ------------------
 1090|    504|            return int(ch1) - int(ch2);
 1091|       |
 1092|       |        // If either ended, then both ended, so equal
 1093|  1.46k|        if (!ch1)
  ------------------
  |  Branch (1093:13): [True: 223, False: 1.24k]
  ------------------
 1094|    223|            break;
 1095|       |
 1096|       |        // Move upwards to next chars
 1097|  1.24k|        psz1++;
 1098|  1.24k|        psz2++;
 1099|  1.24k|    }
 1100|    223|    return 0;
 1101|    727|}
_ZN11xercesc_3_29XMLString14compareNStringEPKDsS2_m:
 1106|      8|{
 1107|      8|    const XMLCh* psz1 = str1;
 1108|      8|    const XMLCh* psz2 = str2;
 1109|       |
 1110|      8|    XMLSize_t curCount = 0;
 1111|     12|    while (curCount < maxChars)
  ------------------
  |  Branch (1111:12): [True: 11, False: 1]
  ------------------
 1112|     11|    {
 1113|       |        // If an inequality, then return difference
 1114|     11|        if (*psz1 != *psz2)
  ------------------
  |  Branch (1114:13): [True: 7, False: 4]
  ------------------
 1115|      7|            return int(*psz1) - int(*psz2);
 1116|       |
 1117|       |        // If either ended, then both ended, so equal
 1118|      4|        if (!*psz1)
  ------------------
  |  Branch (1118:13): [True: 0, False: 4]
  ------------------
 1119|      0|            break;
 1120|       |
 1121|       |        // Move upwards to next chars
 1122|      4|        psz1++;
 1123|      4|        psz2++;
 1124|       |
 1125|       |        //
 1126|       |        //  Bump the count of chars done.
 1127|       |        //
 1128|      4|        curCount++;
 1129|      4|    }
 1130|       |    // If we inspected all the maxChars, then we are equal.
 1131|      1|    return 0;
 1132|      8|}
_ZN11xercesc_3_29XMLString13compareStringEPKDsS2_:
 1146|   127k|{
 1147|   127k|    const XMLCh* psz1 = str1;
 1148|   127k|    const XMLCh* psz2 = str2;
 1149|       |
 1150|   127k|    if (psz1 == 0 || psz2 == 0) {
  ------------------
  |  Branch (1150:9): [True: 0, False: 127k]
  |  Branch (1150:22): [True: 0, False: 127k]
  ------------------
 1151|       |
 1152|      0|        if (psz1 == 0) {
  ------------------
  |  Branch (1152:13): [True: 0, False: 0]
  ------------------
 1153|      0|            return 0 - (int)XMLString::stringLen(psz2);
 1154|      0|        }
 1155|      0|		else if (psz2 == 0) {
  ------------------
  |  Branch (1155:12): [True: 0, False: 0]
  ------------------
 1156|      0|            return (int)XMLString::stringLen(psz1);
 1157|      0|        }
 1158|      0|    }
 1159|       |
 1160|   127k|    for (;;)
 1161|   129k|    {
 1162|       |        // If an inequality, then return the difference
 1163|   129k|        if (*psz1 != *psz2)
  ------------------
  |  Branch (1163:13): [True: 126k, False: 2.66k]
  ------------------
 1164|   126k|            return int(*psz1) - int(*psz2);
 1165|       |
 1166|       |        // If either has ended, then they both ended, so equal
 1167|  2.66k|        if (!*psz1)
  ------------------
  |  Branch (1167:13): [True: 184, False: 2.48k]
  ------------------
 1168|    184|            break;
 1169|       |
 1170|       |        // Move upwards for the next round
 1171|  2.48k|        psz1++;
 1172|  2.48k|        psz2++;
 1173|  2.48k|    }
 1174|    184|    return 0;
 1175|   127k|}
_ZN11xercesc_3_29XMLString10copyStringEPDsPKDs:
 1209|  17.7k|{
 1210|  17.7k|    if (!src)
  ------------------
  |  Branch (1210:9): [True: 0, False: 17.7k]
  ------------------
 1211|      0|    {
 1212|      0|        *target = 0;
 1213|      0|        return;
 1214|      0|    }
 1215|       |
 1216|  17.7k|    XMLCh* pszOut = target;
 1217|  17.7k|    const XMLCh* pszIn = src;
 1218|  7.50M|    while (*pszIn)
  ------------------
  |  Branch (1218:12): [True: 7.48M, False: 17.7k]
  ------------------
 1219|  7.48M|        *pszOut++ = *pszIn++;
 1220|       |
 1221|       |    // Cap off the target where we ended
 1222|  17.7k|    *pszOut = 0;
 1223|  17.7k|}
_ZN11xercesc_3_29XMLString11copyNStringEPDsPKDsm:
 1229|  8.31k|{
 1230|       |    // Return whether we copied it all or hit the max
 1231|  8.31k|    XMLSize_t len = stringLen(src);
 1232|  8.31k|    if(len > maxChars)
  ------------------
  |  Branch (1232:8): [True: 16, False: 8.30k]
  ------------------
 1233|     16|    {
 1234|     16|        XMLString::moveChars(target, src, maxChars);
 1235|     16|        target[maxChars] = 0;
 1236|     16|        return false;
 1237|     16|    }
 1238|  8.30k|    XMLString::moveChars(target, src, len+1);
 1239|  8.30k|    return true;
 1240|  8.31k|}
_ZN11xercesc_3_29XMLString7findAnyEPDsPKDs:
 1263|  9.68k|{
 1264|  9.68k|    XMLCh* srcPtr = toSearch;
 1265|  14.8M|    while (*srcPtr)
  ------------------
  |  Branch (1265:12): [True: 14.8M, False: 8.76k]
  ------------------
 1266|  14.8M|    {
 1267|  14.8M|        const XMLCh* listPtr = searchList;
 1268|  14.8M|        const XMLCh  curCh = *srcPtr;
 1269|       |
 1270|  31.5M|        while (*listPtr)
  ------------------
  |  Branch (1270:16): [True: 16.7M, False: 14.8M]
  ------------------
 1271|  16.7M|        {
 1272|  16.7M|            if (curCh == *listPtr++)
  ------------------
  |  Branch (1272:17): [True: 922, False: 16.7M]
  ------------------
 1273|    922|                return srcPtr;
 1274|  16.7M|        }
 1275|  14.8M|        srcPtr++;
 1276|  14.8M|    }
 1277|  8.76k|    return 0;
 1278|  9.68k|}
_ZN11xercesc_3_29XMLString7indexOfEPKDsDs:
 1315|   132k|{
 1316|   132k|    if (!toSearch || !*toSearch) return -1;
  ------------------
  |  Branch (1316:9): [True: 0, False: 132k]
  |  Branch (1316:22): [True: 0, False: 132k]
  ------------------
 1317|       |
 1318|   132k|    const XMLCh* srcPtr = toSearch;
 1319|  9.23M|    while (*srcPtr)
  ------------------
  |  Branch (1319:12): [True: 9.18M, False: 50.7k]
  ------------------
 1320|  9.18M|        if (ch == *srcPtr++)
  ------------------
  |  Branch (1320:13): [True: 81.5k, False: 9.10M]
  ------------------
 1321|  81.5k|            return (int)(srcPtr - toSearch - 1);
 1322|  50.7k|    return -1;
 1323|   132k|}
_ZN11xercesc_3_29XMLString7indexOfEPKDsDsmPNS_13MemoryManagerE:
 1330|    176|{
 1331|    176|    const XMLSize_t len = stringLen(toSearch);
 1332|       |
 1333|       |    // Make sure the start index is within the XMLString bounds
 1334|    176|    if (fromIndex >= len) {
  ------------------
  |  Branch (1334:9): [True: 0, False: 176]
  ------------------
 1335|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Str_StartIndexPastEnd, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1336|      0|    }
 1337|       |
 1338|    176|    const XMLCh* srcPtr = toSearch+fromIndex;
 1339|  6.29M|    while (*srcPtr)
  ------------------
  |  Branch (1339:12): [True: 6.29M, False: 163]
  ------------------
 1340|  6.29M|        if (ch == *srcPtr++)
  ------------------
  |  Branch (1340:13): [True: 13, False: 6.29M]
  ------------------
 1341|     13|            return (int)(srcPtr - toSearch - 1);
 1342|    163|    return -1;
 1343|    176|}
_ZN11xercesc_3_29XMLString9textToBinEPKDsRjPNS_13MemoryManagerE:
 1407|    184|{
 1408|    184|    toFill = 0;
 1409|       |
 1410|       |    // If no string, then its a failure
 1411|    184|    if ((!toConvert) || (!*toConvert))
  ------------------
  |  Branch (1411:9): [True: 0, False: 184]
  |  Branch (1411:25): [True: 1, False: 183]
  ------------------
 1412|      1|        return false;
 1413|       |
 1414|    183|	XMLCh* trimmedStr = XMLString::replicate(toConvert, manager);
 1415|    183|	ArrayJanitor<XMLCh> jan1(trimmedStr, manager);
 1416|    183|	XMLString::trim(trimmedStr);
 1417|    183|    XMLSize_t trimmedStrLen = XMLString::stringLen(trimmedStr);
 1418|       |
 1419|    183|	if ( !trimmedStrLen )
  ------------------
  |  Branch (1419:7): [True: 7, False: 176]
  ------------------
 1420|      7|		return false;
 1421|       |
 1422|       |	// we don't allow '-' sign
 1423|    176|	if (XMLString::indexOf(trimmedStr, chDash, 0, manager) != -1)
  ------------------
  |  Branch (1423:6): [True: 13, False: 163]
  ------------------
 1424|     13|		return false;
 1425|       |
 1426|       |	//the errno set by previous run is NOT automatically cleared
 1427|    163|	errno = 0;
 1428|       |
 1429|    163|	char *nptr = XMLString::transcode(trimmedStr, manager);
 1430|    163|    ArrayJanitor<char> jan2(nptr, manager);
 1431|       |
 1432|    163|    char *endptr;
 1433|       |	 //
 1434|       |     // REVISIT: conversion of (unsigned long) to (unsigned int)
 1435|       |	 //          may truncate value on IA64
 1436|    163|    toFill = (unsigned int) strtoul(nptr, &endptr, 10);
 1437|       |
 1438|       |	// check if all chars are valid char
 1439|       |	// check if overflow/underflow occurs
 1440|    163|	if ( ( (endptr - nptr) != (int) trimmedStrLen) ||
  ------------------
  |  Branch (1440:7): [True: 56, False: 107]
  ------------------
 1441|    163|         (errno == ERANGE)                      )
  ------------------
  |  Branch (1441:10): [True: 1, False: 106]
  ------------------
 1442|     50|		return false;
 1443|       |
 1444|    113|    return true;
 1445|    163|}
_ZN11xercesc_3_29XMLString8parseIntEPKDsPNS_13MemoryManagerE:
 1449|      4|{
 1450|       |    // If no string, or empty string, then it is a failure
 1451|      4|    if ((!toConvert) || (!*toConvert))
  ------------------
  |  Branch (1451:9): [True: 0, False: 4]
  |  Branch (1451:25): [True: 0, False: 4]
  ------------------
 1452|      0|        ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_null_ptr, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1453|       |
 1454|      4|	XMLCh* trimmedStr = XMLString::replicate(toConvert, manager);
 1455|      4|	ArrayJanitor<XMLCh> jan1(trimmedStr, manager);
 1456|      4|	XMLString::trim(trimmedStr);
 1457|      4|    XMLSize_t trimmedStrLen = XMLString::stringLen(trimmedStr);
 1458|       |
 1459|      4|	if ( !trimmedStrLen )
  ------------------
  |  Branch (1459:7): [True: 0, False: 4]
  ------------------
 1460|      0|        ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_null_ptr, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1461|       |
 1462|       |	//the errno set by previous run is NOT automatically cleared
 1463|      4|	errno = 0;
 1464|       |
 1465|      4|	char *nptr = XMLString::transcode(trimmedStr, manager);
 1466|      4|    ArrayJanitor<char> jan2(nptr, manager);
 1467|       |
 1468|      4|    char *endptr;
 1469|      4|    long retVal = strtol(nptr, &endptr, 10);
 1470|       |
 1471|       |	// check if all chars are valid char
 1472|      4|	if ( (endptr - nptr) != (int) trimmedStrLen)
  ------------------
  |  Branch (1472:7): [True: 0, False: 4]
  ------------------
 1473|      0|		ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::XMLNUM_Inv_chars, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1474|       |
 1475|       |	// check if overflow/underflow occurs
 1476|      4|    if (errno == ERANGE)
  ------------------
  |  Branch (1476:9): [True: 0, False: 4]
  ------------------
 1477|      0|        ThrowXMLwithMemMgr(NumberFormatException, XMLExcepts::Str_ConvertOverflow, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1478|       |
 1479|       |	 //
 1480|       |     // REVISIT: conversion of (long) to (int)
 1481|       |	 //          may truncate value on IA64
 1482|      4|	return (int) retVal;
 1483|      4|}
_ZN11xercesc_3_29XMLString4trimEPDs:
 1487|    187|{
 1488|    187|    const XMLSize_t len = stringLen(toTrim);
 1489|       |
 1490|    187|    XMLSize_t skip, scrape;
 1491|  2.22k|    for (skip = 0; skip < len; skip++)
  ------------------
  |  Branch (1491:20): [True: 2.21k, False: 7]
  ------------------
 1492|  2.21k|    {
 1493|  2.21k|        if (!XMLChar1_0::isWhitespace(toTrim[skip]))
  ------------------
  |  Branch (1493:13): [True: 180, False: 2.03k]
  ------------------
 1494|    180|            break;
 1495|  2.21k|    }
 1496|       |
 1497|  1.78k|    for (scrape = len; scrape > skip; scrape--)
  ------------------
  |  Branch (1497:24): [True: 1.78k, False: 7]
  ------------------
 1498|  1.78k|    {
 1499|  1.78k|        if (!XMLChar1_0::isWhitespace(toTrim[scrape - 1]))
  ------------------
  |  Branch (1499:13): [True: 180, False: 1.60k]
  ------------------
 1500|    180|            break;
 1501|  1.78k|    }
 1502|       |
 1503|       |    // Cap off at the scrap point
 1504|    187|    if (scrape != len)
  ------------------
  |  Branch (1504:9): [True: 87, False: 100]
  ------------------
 1505|     87|        toTrim[scrape] = 0;
 1506|       |
 1507|    187|    if (skip)
  ------------------
  |  Branch (1507:9): [True: 148, False: 39]
  ------------------
 1508|    148|    {
 1509|       |        // Copy the chars down
 1510|    148|        XMLSize_t index = 0;
 1511|  6.23M|        while (toTrim[skip])
  ------------------
  |  Branch (1511:16): [True: 6.23M, False: 148]
  ------------------
 1512|  6.23M|            toTrim[index++] = toTrim[skip++];
 1513|       |
 1514|    148|        toTrim[index] = 0;
 1515|    148|    }
 1516|    187|}
_ZN11xercesc_3_29XMLString14upperCaseASCIIEPDs:
 1526|  15.9k|{
 1527|  15.9k|    XMLCh* psz1 = toUpperCase;
 1528|       |
 1529|  15.9k|    if (!psz1)
  ------------------
  |  Branch (1529:9): [True: 0, False: 15.9k]
  ------------------
 1530|      0|        return;
 1531|       |
 1532|   230k|    while (*psz1) {
  ------------------
  |  Branch (1532:12): [True: 214k, False: 15.9k]
  ------------------
 1533|   214k|        if (*psz1 >= chLatin_a && *psz1 <= chLatin_z)
  ------------------
  |  Branch (1533:13): [True: 1.23k, False: 212k]
  |  Branch (1533:35): [True: 1.23k, False: 0]
  ------------------
 1534|  1.23k|            *psz1 = *psz1 - chLatin_a + chLatin_A;
 1535|       |
 1536|   214k|        psz1++;
 1537|   214k|    }
 1538|  15.9k|}
_ZN11xercesc_3_29XMLString9subStringEPDsPKDsmmPNS_13MemoryManagerE:
 1565|      3|{
 1566|      3|    subString(targetStr, srcStr, startIndex, endIndex, stringLen(srcStr), manager);
 1567|      3|}
_ZN11xercesc_3_29XMLString9subStringEPDsPKDsmmmPNS_13MemoryManagerE:
 1573|      3|{
 1574|       |    //if (startIndex < 0 || endIndex < 0)
 1575|       |    //    ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Str_NegativeIndex);
 1576|       |
 1577|      3|    if (targetStr == 0)
  ------------------
  |  Branch (1577:9): [True: 0, False: 3]
  ------------------
 1578|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Str_ZeroSizedTargetBuf, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1579|       |
 1580|       |    // Make sure the start index is within the XMLString bounds
 1581|      3|    if (startIndex > endIndex || endIndex > srcStrLength)
  ------------------
  |  Branch (1581:9): [True: 0, False: 3]
  |  Branch (1581:34): [True: 0, False: 3]
  ------------------
 1582|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Str_StartIndexPastEnd, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1583|       |
 1584|      3|    const XMLSize_t copySize = endIndex - startIndex;
 1585|       |
 1586|     46|    for (XMLSize_t i= startIndex; i < endIndex; i++) {
  ------------------
  |  Branch (1586:35): [True: 43, False: 3]
  ------------------
 1587|     43|        targetStr[i-startIndex] = srcStr[i];
 1588|     43|    }
 1589|       |
 1590|      3|    targetStr[copySize] = 0;
 1591|      3|}
_ZN11xercesc_3_29XMLString12isWSReplacedEPKDs:
 1749|  10.6k|{
 1750|       |    // If no string, then its a OK
 1751|  10.6k|    if (( !toCheck ) || ( !*toCheck ))
  ------------------
  |  Branch (1751:9): [True: 0, False: 10.6k]
  |  Branch (1751:25): [True: 0, False: 10.6k]
  ------------------
 1752|      0|        return true;
 1753|       |
 1754|  10.6k|    const XMLCh* startPtr = toCheck;
 1755|  32.9M|    while ( *startPtr )
  ------------------
  |  Branch (1755:13): [True: 32.9M, False: 6.16k]
  ------------------
 1756|  32.9M|    {
 1757|  32.9M|        if ( ( *startPtr == chCR) ||
  ------------------
  |  Branch (1757:14): [True: 10, False: 32.9M]
  ------------------
 1758|  32.9M|             ( *startPtr == chLF) ||
  ------------------
  |  Branch (1758:14): [True: 15, False: 32.9M]
  ------------------
 1759|  32.9M|             ( *startPtr == chHTab))
  ------------------
  |  Branch (1759:14): [True: 4.49k, False: 32.9M]
  ------------------
 1760|  4.52k|        return false;
 1761|       |
 1762|  32.9M|        startPtr++;
 1763|  32.9M|    }
 1764|       |
 1765|  6.16k|    return true;
 1766|  10.6k|}
_ZN11xercesc_3_29XMLString9replaceWSEPDsPNS_13MemoryManagerE:
 1775|  4.52k|{
 1776|       |    // If no string, then its a OK
 1777|  4.52k|    if (( !toConvert ) || ( !*toConvert ))
  ------------------
  |  Branch (1777:9): [True: 0, False: 4.52k]
  |  Branch (1777:27): [True: 0, False: 4.52k]
  ------------------
 1778|      0|        return;
 1779|       |
 1780|  4.52k|    XMLCh* cursorPtr = toConvert;
 1781|  35.1k|    while ( *cursorPtr )
  ------------------
  |  Branch (1781:13): [True: 30.6k, False: 4.52k]
  ------------------
 1782|  30.6k|    {
 1783|  30.6k|        if ( ( *cursorPtr == chCR) ||
  ------------------
  |  Branch (1783:14): [True: 311, False: 30.3k]
  ------------------
 1784|  30.6k|             ( *cursorPtr == chLF) ||
  ------------------
  |  Branch (1784:14): [True: 589, False: 29.7k]
  ------------------
 1785|  30.6k|             ( *cursorPtr == chHTab))
  ------------------
  |  Branch (1785:14): [True: 5.23k, False: 24.5k]
  ------------------
 1786|  6.13k|            *cursorPtr = chSpace;
 1787|       |
 1788|  30.6k|        cursorPtr++;
 1789|  30.6k|    }
 1790|  4.52k|}
_ZN11xercesc_3_29XMLString13isWSCollapsedEPKDs:
 1800|  3.98k|{
 1801|  3.98k|    if (( !toCheck ) || ( !*toCheck ))
  ------------------
  |  Branch (1801:9): [True: 0, False: 3.98k]
  |  Branch (1801:25): [True: 0, False: 3.98k]
  ------------------
 1802|      0|        return true;
 1803|       |
 1804|       |    // shall be whitespace::replaced first
 1805|  3.98k|    if ( !isWSReplaced(toCheck) )
  ------------------
  |  Branch (1805:10): [True: 0, False: 3.98k]
  ------------------
 1806|      0|        return false;
 1807|       |
 1808|       |    // no leading or trailing space
 1809|  3.98k|    if ((*toCheck == chSpace) ||
  ------------------
  |  Branch (1809:9): [True: 0, False: 3.98k]
  ------------------
 1810|  3.98k|        (toCheck[XMLString::stringLen(toCheck)-1] == chSpace))
  ------------------
  |  Branch (1810:9): [True: 0, False: 3.98k]
  ------------------
 1811|      0|        return false;
 1812|       |
 1813|  3.98k|    const XMLCh* startPtr = toCheck;
 1814|  3.98k|    XMLCh theChar;
 1815|  3.98k|    bool  inSpace = false;
 1816|  16.4M|    while ( (theChar = *startPtr) != 0 )
  ------------------
  |  Branch (1816:13): [True: 16.4M, False: 3.07k]
  ------------------
 1817|  16.4M|    {
 1818|  16.4M|        if ( theChar == chSpace)
  ------------------
  |  Branch (1818:14): [True: 17.0k, False: 16.4M]
  ------------------
 1819|  17.0k|        {
 1820|  17.0k|            if (inSpace)
  ------------------
  |  Branch (1820:17): [True: 912, False: 16.0k]
  ------------------
 1821|    912|                return false;
 1822|  16.0k|            else
 1823|  16.0k|                inSpace = true;
 1824|  17.0k|        }
 1825|  16.4M|        else
 1826|  16.4M|            inSpace = false;
 1827|       |
 1828|  16.4M|        startPtr++;
 1829|       |
 1830|  16.4M|    }
 1831|       |
 1832|  3.07k|    return true;
 1833|  3.98k|}
_ZN11xercesc_3_29XMLString10collapseWSEPDsPNS_13MemoryManagerE:
 1841|  6.70k|{
 1842|       |    // If no string, then its a failure
 1843|  6.70k|    if (( !toConvert ) || ( !*toConvert ))
  ------------------
  |  Branch (1843:9): [True: 0, False: 6.70k]
  |  Branch (1843:27): [True: 0, False: 6.70k]
  ------------------
 1844|      0|        return;
 1845|       |
 1846|       |    // replace whitespace first
 1847|  6.70k|    if(!isWSReplaced(toConvert))
  ------------------
  |  Branch (1847:8): [True: 4.52k, False: 2.17k]
  ------------------
 1848|  4.52k|        replaceWS(toConvert, manager);
 1849|       |
 1850|       |    // remove leading spaces
 1851|  6.70k|    XMLCh* startPtr = toConvert;
 1852|  12.2k|    while ( *startPtr == chSpace )
  ------------------
  |  Branch (1852:13): [True: 5.58k, False: 6.70k]
  ------------------
 1853|  5.58k|        startPtr++;
 1854|       |
 1855|  6.70k|    if (!*startPtr)
  ------------------
  |  Branch (1855:9): [True: 2.71k, False: 3.98k]
  ------------------
 1856|  2.71k|    {
 1857|  2.71k|        *toConvert = chNull;
 1858|  2.71k|        return;
 1859|  2.71k|    }
 1860|       |
 1861|       |    // remove trailing spaces
 1862|  3.98k|    XMLCh* endPtr = toConvert + stringLen(toConvert);
 1863|  4.81k|    while (*(endPtr - 1) == chSpace)
  ------------------
  |  Branch (1863:12): [True: 821, False: 3.98k]
  ------------------
 1864|    821|        endPtr--;
 1865|  3.98k|    *endPtr = chNull;
 1866|       |
 1867|       |    // move data to beginning only if there were spaces in front
 1868|  3.98k|    if(startPtr != toConvert)
  ------------------
  |  Branch (1868:8): [True: 989, False: 3.00k]
  ------------------
 1869|    989|        XMLString::moveChars(toConvert, startPtr, endPtr - startPtr + 1);
 1870|       |
 1871|  3.98k|    if(!isWSCollapsed(toConvert))
  ------------------
  |  Branch (1871:8): [True: 912, False: 3.07k]
  ------------------
 1872|    912|    {
 1873|       |        //
 1874|       |        //  Work through what remains and chop continuous spaces
 1875|       |        //
 1876|    912|        XMLCh* retPtr = toConvert;
 1877|    912|        startPtr = toConvert;
 1878|    912|        bool inSpace = false;
 1879|  14.3k|        while (*startPtr)
  ------------------
  |  Branch (1879:16): [True: 13.4k, False: 912]
  ------------------
 1880|  13.4k|        {
 1881|  13.4k|            if ( *startPtr == chSpace)
  ------------------
  |  Branch (1881:18): [True: 3.60k, False: 9.87k]
  ------------------
 1882|  3.60k|            {
 1883|       |                // copy a single space, then ignore subsequent
 1884|  3.60k|                if (!inSpace)
  ------------------
  |  Branch (1884:21): [True: 2.43k, False: 1.17k]
  ------------------
 1885|  2.43k|                {
 1886|  2.43k|                    inSpace = true;
 1887|  2.43k|                    *retPtr++ = chSpace;
 1888|  2.43k|                }
 1889|  3.60k|            }
 1890|  9.87k|            else
 1891|  9.87k|            {
 1892|  9.87k|                inSpace = false;
 1893|  9.87k|                *retPtr++ = *startPtr;
 1894|  9.87k|            }
 1895|       |
 1896|  13.4k|            startPtr++;
 1897|  13.4k|        }
 1898|       |
 1899|    912|        *retPtr = chNull;
 1900|    912|    }
 1901|  3.98k|}
_ZN11xercesc_3_29XMLString10removeCharEPKDsRS1_RNS_9XMLBufferE:
 1934|  2.39k|{
 1935|  2.39k|    if(!srcString) return;
  ------------------
  |  Branch (1935:8): [True: 1, False: 2.39k]
  ------------------
 1936|  2.39k|    const XMLCh* pszSrc = srcString;
 1937|  2.39k|    XMLCh c;
 1938|       |
 1939|  2.39k|    dstBuffer.reset();
 1940|       |
 1941|  7.80M|    while ((c=*pszSrc++)!=0)
  ------------------
  |  Branch (1941:12): [True: 7.79M, False: 2.39k]
  ------------------
 1942|  7.79M|    {
 1943|  7.79M|        if (c != toRemove)
  ------------------
  |  Branch (1943:13): [True: 7.79M, False: 18]
  ------------------
 1944|  7.79M|            dstBuffer.append(c);
 1945|  7.79M|    }
 1946|  2.39k|}
_ZN11xercesc_3_29XMLString10initStringEPNS_16XMLLCPTranscoderEPNS_13MemoryManagerE:
 2030|      1|{
 2031|       |    // Store away the default transcoder that we are to use
 2032|      1|    gTranscoder = defToUse;
 2033|       |
 2034|       |    // Store memory manager
 2035|      1|    fgMemoryManager = manager;
 2036|      1|}

_ZN11xercesc_3_29XMLString9moveCharsEPDsPKDsm:
 1456|  5.33M|{
 1457|  5.33M|    memmove(targetStr, srcStr, count * sizeof(XMLCh));
 1458|  5.33M|}
_ZN11xercesc_3_29XMLString9stringLenEPKDs:
 1461|  6.04M|{
 1462|  6.04M|    if (src == 0)
  ------------------
  |  Branch (1462:9): [True: 466, False: 6.04M]
  ------------------
 1463|    466|        return 0;
 1464|       |
 1465|  6.04M|    const XMLCh* pszTmp = src;
 1466|       |
 1467|   274M|    while (*pszTmp++) ;
  ------------------
  |  Branch (1467:12): [True: 268M, False: 6.04M]
  ------------------
 1468|       |
 1469|  6.04M|    return (pszTmp - src - 1);
 1470|  6.04M|}
_ZN11xercesc_3_29XMLString9replicateEPKDsPNS_13MemoryManagerE:
 1474|   287k|{
 1475|       |    // If a null string, return a null string!
 1476|   287k|    XMLCh* ret = 0;
 1477|   287k|    if (toRep)
  ------------------
  |  Branch (1477:9): [True: 256k, False: 30.6k]
  ------------------
 1478|   256k|    {
 1479|   256k|        const XMLSize_t len = stringLen(toRep);
 1480|   256k|        ret = (XMLCh*) manager->allocate((len+1) * sizeof(XMLCh)); //new XMLCh[len + 1];
 1481|   256k|        memcpy(ret, toRep, (len + 1) * sizeof(XMLCh));
 1482|   256k|    }
 1483|   287k|    return ret;
 1484|   287k|}
_ZN11xercesc_3_29XMLString10startsWithEPKDsS2_:
 1488|      8|{
 1489|      8|    return (compareNString(toTest, prefix, stringLen(prefix)) == 0);
 1490|      8|}
_ZN11xercesc_3_29XMLString6equalsEPKDsS2_:
 1525|   142M|{
 1526|   142M|    if (str1 == str2)
  ------------------
  |  Branch (1526:9): [True: 44.7k, False: 142M]
  ------------------
 1527|  44.7k|        return true;
 1528|       |
 1529|   142M|    if (str1 == 0 || str2 == 0)
  ------------------
  |  Branch (1529:9): [True: 3, False: 142M]
  |  Branch (1529:22): [True: 0, False: 142M]
  ------------------
 1530|      3|        return ((!str1 || !*str1) && (!str2 || !*str2));
  ------------------
  |  Branch (1530:18): [True: 3, False: 0]
  |  Branch (1530:27): [True: 0, False: 0]
  |  Branch (1530:39): [True: 0, False: 3]
  |  Branch (1530:48): [True: 0, False: 3]
  ------------------
 1531|       |
 1532|   173M|    while (*str1)
  ------------------
  |  Branch (1532:12): [True: 143M, False: 29.8M]
  ------------------
 1533|   143M|        if(*str1++ != *str2++)  // they are different (or str2 is shorter and we hit the NULL)
  ------------------
  |  Branch (1533:12): [True: 112M, False: 30.5M]
  ------------------
 1534|   112M|            return false;
 1535|       |
 1536|       |    // either both ended (and *str2 is 0 too), or str2 is longer
 1537|  29.8M|    return (*str2==0);
 1538|   142M|}
_ZN11xercesc_3_29XMLString4hashEPKDsm:
 1598|  3.48M|{
 1599|  3.48M|    if (tohash == 0 || *tohash == 0)
  ------------------
  |  Branch (1599:9): [True: 0, False: 3.48M]
  |  Branch (1599:24): [True: 36.9k, False: 3.44M]
  ------------------
 1600|  36.9k|        return 0;
 1601|       |
 1602|  3.44M|    const XMLCh* curCh = tohash;
 1603|  3.44M|    XMLSize_t hashVal = (XMLSize_t)(*curCh++);
 1604|       |
 1605|   129M|    while (*curCh)
  ------------------
  |  Branch (1605:12): [True: 125M, False: 3.44M]
  ------------------
 1606|   125M|        hashVal = (hashVal * 38) + (hashVal >> 24) + (XMLSize_t)(*curCh++);
 1607|       |
 1608|       |    // Divide by modulus
 1609|  3.44M|    return hashVal % hashModulus;
 1610|  3.48M|}

_ZN11xercesc_3_218XMLStringTokenizerC2EPKDsPNS_13MemoryManagerE:
   54|      1|{
   55|      1|    CleanupType cleanup(this, &XMLStringTokenizer::cleanUp);
   56|       |
   57|      1|	try {
   58|      1|        if (fStringLen > 0) {
  ------------------
  |  Branch (58:13): [True: 1, False: 0]
  ------------------
   59|      1|            fTokens = new (fMemoryManager) RefArrayVectorOf<XMLCh>(4, true, fMemoryManager);
   60|      1|        }
   61|      1|    }
   62|      1|    catch(const OutOfMemoryException&)
   63|      1|    {
   64|      0|        cleanup.release();
   65|       |
   66|      0|        throw;
   67|      0|    }
   68|       |
   69|      1|    cleanup.release();
   70|      1|}
_ZN11xercesc_3_218XMLStringTokenizerD2Ev:
  100|      1|{
  101|      1|	cleanUp();
  102|      1|}
_ZN11xercesc_3_218XMLStringTokenizer7cleanUpEv:
  107|      1|void XMLStringTokenizer::cleanUp() {
  108|       |
  109|      1|	fMemoryManager->deallocate(fString);//delete [] fString;
  110|      1|    if (fDelimeters != fgDelimeters) {
  ------------------
  |  Branch (110:9): [True: 0, False: 1]
  ------------------
  111|      0|        fMemoryManager->deallocate((void*)fDelimeters);//delete [] fDelimeters;
  112|      0|    }
  113|      1|    delete fTokens;
  114|      1|}
_ZN11xercesc_3_218XMLStringTokenizer9nextTokenEv:
  120|      2|XMLCh* XMLStringTokenizer::nextToken() {
  121|       |
  122|      2|    if (fOffset >= fStringLen) {
  ------------------
  |  Branch (122:9): [True: 1, False: 1]
  ------------------
  123|      1|        return 0;
  124|      1|    }
  125|       |
  126|      1|    bool tokFound = false;
  127|      1|    XMLSize_t startIndex = fOffset;
  128|      1|    XMLSize_t endIndex = fOffset;
  129|       |
  130|      5|    for (; endIndex < fStringLen; endIndex++) {
  ------------------
  |  Branch (130:12): [True: 4, False: 1]
  ------------------
  131|       |
  132|      4|        if (isDelimeter(fString[endIndex])) {
  ------------------
  |  Branch (132:13): [True: 0, False: 4]
  ------------------
  133|       |
  134|      0|			if (tokFound) {
  ------------------
  |  Branch (134:8): [True: 0, False: 0]
  ------------------
  135|      0|                break;
  136|      0|            }
  137|       |
  138|      0|			startIndex++;
  139|      0|			continue;
  140|      0|        }
  141|       |
  142|      4|        tokFound = true;
  143|      4|    }
  144|       |
  145|      1|    fOffset = endIndex;
  146|       |
  147|      1|    if (tokFound) {
  ------------------
  |  Branch (147:9): [True: 1, False: 0]
  ------------------
  148|       |
  149|      1|        XMLCh* tokStr = (XMLCh*) fMemoryManager->allocate
  150|      1|        (
  151|      1|            (endIndex - startIndex + 1) * sizeof(XMLCh)
  152|      1|        );//new XMLCh[(endIndex - startIndex) + 1];
  153|       |
  154|      1|        XMLString::subString(tokStr, fString, startIndex, endIndex, fMemoryManager);
  155|      1|        fTokens->addElement(tokStr);
  156|       |
  157|      1|        return tokStr;
  158|      1|	}
  159|       |
  160|      0|    return 0;
  161|      1|}
_ZN11xercesc_3_218XMLStringTokenizer13hasMoreTokensEv:
  164|      2|bool XMLStringTokenizer::hasMoreTokens() {
  165|       |
  166|      2|    if (countTokens() > 0)
  ------------------
  |  Branch (166:9): [True: 1, False: 1]
  ------------------
  167|      1|        return true;
  168|       |
  169|      1|	return false;
  170|      2|}

_ZN11xercesc_3_218XMLStringTokenizer11isDelimeterEDs:
  172|      8|inline bool XMLStringTokenizer::isDelimeter(const XMLCh ch) {
  173|       |
  174|      8|    return XMLString::indexOf(fDelimeters, ch) == -1 ? false : true;
  ------------------
  |  Branch (174:12): [True: 8, False: 0]
  ------------------
  175|      8|}
_ZN11xercesc_3_218XMLStringTokenizer11countTokensEv:
  181|      2|inline unsigned int XMLStringTokenizer::countTokens() {
  182|       |
  183|      2|    if (fStringLen == 0)
  ------------------
  |  Branch (183:9): [True: 0, False: 2]
  ------------------
  184|      0|		return 0;
  185|       |
  186|      2|    unsigned int tokCount = 0;
  187|      2|    bool inToken = false;
  188|       |
  189|      6|    for (XMLSize_t i= fOffset; i< fStringLen; i++) {
  ------------------
  |  Branch (189:32): [True: 4, False: 2]
  ------------------
  190|       |
  191|      4|        if (isDelimeter(fString[i])) {
  ------------------
  |  Branch (191:13): [True: 0, False: 4]
  ------------------
  192|       |
  193|      0|            if (inToken) {
  ------------------
  |  Branch (193:17): [True: 0, False: 0]
  ------------------
  194|      0|                inToken = false;
  195|      0|            }
  196|       |
  197|      0|            continue;
  198|      0|        }
  199|       |
  200|      4|		if (!inToken) {
  ------------------
  |  Branch (200:7): [True: 1, False: 3]
  ------------------
  201|       |
  202|      1|            tokCount++;
  203|      1|            inToken = true;
  204|      1|        }
  205|       |
  206|      4|    } // end for
  207|       |
  208|      2|    return tokCount;
  209|      2|}

_ZN11xercesc_3_26XMLURL12lookupByNameEPKDs:
  145|    264|{
  146|    767|    for (unsigned int index = 0; index < XMLURL::Protocols_Count; index++)
  ------------------
  |  Branch (146:34): [True: 725, False: 42]
  ------------------
  147|    725|    {
  148|    725|        if (!XMLString::compareIStringASCII(protoName, gProtoList[index].prefix))
  ------------------
  |  Branch (148:13): [True: 222, False: 503]
  ------------------
  149|    222|            return gProtoList[index].protocol;
  150|    725|    }
  151|     42|    return XMLURL::Unknown;
  152|    264|}
_ZN11xercesc_3_26XMLURLC2EPNS_13MemoryManagerE:
  172|  4.51k|{
  173|  4.51k|}
_ZN11xercesc_3_26XMLURLC2ERKS0_:
  384|    239|{
  385|    239|    CleanupType cleanup(this, &XMLURL::cleanUp);
  386|       |
  387|    239|    try
  388|    239|    {
  389|    239|        fFragment = XMLString::replicate(toCopy.fFragment, fMemoryManager);
  390|    239|        fHost = XMLString::replicate(toCopy.fHost, fMemoryManager);
  391|    239|        fPassword = XMLString::replicate(toCopy.fPassword, fMemoryManager);
  392|    239|        fPath = XMLString::replicate(toCopy.fPath, fMemoryManager);
  393|    239|        fQuery = XMLString::replicate(toCopy.fQuery, fMemoryManager);
  394|    239|        fUser = XMLString::replicate(toCopy.fUser, fMemoryManager);
  395|    239|        fURLText = XMLString::replicate(toCopy.fURLText, fMemoryManager);
  396|    239|    }
  397|    239|    catch(const OutOfMemoryException&)
  398|    239|    {
  399|      0|        cleanup.release();
  400|       |
  401|      0|        throw;
  402|      0|    }
  403|       |
  404|    239|    cleanup.release();
  405|    239|}
_ZN11xercesc_3_26XMLURLD2Ev:
  408|  4.75k|{
  409|  4.75k|    cleanUp();
  410|  4.75k|}
_ZNK11xercesc_3_26XMLURL10getPortNumEv:
  459|     89|{
  460|       |    //
  461|       |    //  If it was not provided explicitly, then lets return the default one
  462|       |    //  for the protocol.
  463|       |    //
  464|     89|    if (!fPortNum)
  ------------------
  |  Branch (464:9): [True: 21, False: 68]
  ------------------
  465|     21|    {
  466|     21|        if (fProtocol == Unknown)
  ------------------
  |  Branch (466:13): [True: 0, False: 21]
  ------------------
  467|      0|            return 0;
  468|     21|        return gProtoList[fProtocol].defPort;
  469|     21|    }
  470|     68|    return fPortNum;
  471|     89|}
_ZNK11xercesc_3_26XMLURL15getProtocolNameEv:
  475|    150|{
  476|       |    // Check to see if its ever been set
  477|    150|    if (fProtocol == Unknown)
  ------------------
  |  Branch (477:9): [True: 0, False: 150]
  ------------------
  478|      0|        ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_NoProtocolPresent, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  479|       |
  480|    150|    return gProtoList[fProtocol].prefix;
  481|    150|}
_ZN11xercesc_3_26XMLURL6setURLEPKDsS2_RS0_:
  528|  2.39k|{
  529|  2.39k|    cleanUp();
  530|       |
  531|       |    // Parse our URL string
  532|  2.39k|    if (parse(relativeURL, xmlURL))
  ------------------
  |  Branch (532:9): [True: 2.26k, False: 127]
  ------------------
  533|  2.26k|    {
  534|       |	    //  If its relative and the base is non-null and non-empty, then
  535|       |	    //  parse the base URL string and conglomerate them.
  536|       |	    //
  537|  2.26k|	    if (isRelative() && baseURL && *baseURL)
  ------------------
  |  Branch (537:10): [True: 2.11k, False: 150]
  |  Branch (537:26): [True: 2.11k, False: 0]
  |  Branch (537:37): [True: 2.11k, False: 0]
  ------------------
  538|  2.11k|	    {
  539|  2.11k|	        XMLURL basePart(fMemoryManager);
  540|  2.11k|            if (parse(baseURL, basePart)  && conglomerateWithBase(basePart, false))
  ------------------
  |  Branch (540:17): [True: 2.11k, False: 0]
  |  Branch (540:46): [True: 0, False: 2.11k]
  ------------------
  541|      0|            {
  542|      0|		        return true;
  543|      0|		    }
  544|  2.11k|	    }
  545|    150|        else
  546|    150|            return true;
  547|  2.26k|    }
  548|  2.24k|    return false;
  549|  2.39k|}
_ZNK11xercesc_3_26XMLURL10isRelativeEv:
  569|  4.53k|{
  570|       |    // If no protocol then relative
  571|  4.53k|    if (fProtocol == Unknown)
  ------------------
  |  Branch (571:9): [True: 4.23k, False: 303]
  ------------------
  572|  4.23k|        return true;
  573|       |
  574|       |    // If no path, or the path is not absolute, then relative
  575|    303|    if (!fPath)
  ------------------
  |  Branch (575:9): [True: 2, False: 301]
  ------------------
  576|      2|        return true;
  577|       |
  578|    301|    if (*fPath != chForwardSlash)
  ------------------
  |  Branch (578:9): [True: 1, False: 300]
  ------------------
  579|      1|        return true;
  580|       |
  581|    300|    return false;
  582|    301|}
_ZNK11xercesc_3_26XMLURL13makeNewStreamEv:
  591|    150|{
  592|       |    //
  593|       |    //  If its a local host, then we short circuit it and use our own file
  594|       |    //  stream support. Otherwise, we just let it fall through and let the
  595|       |    //  installed network access object provide a stream.
  596|       |    //
  597|    150|    if (fProtocol == XMLURL::File)
  ------------------
  |  Branch (597:9): [True: 0, False: 150]
  ------------------
  598|      0|    {
  599|      0|        if (!fHost || !XMLString::compareIStringASCII(fHost, XMLUni::fgLocalHostString))
  ------------------
  |  Branch (599:13): [True: 0, False: 0]
  |  Branch (599:23): [True: 0, False: 0]
  ------------------
  600|      0|        {
  601|       |
  602|      0|            XMLCh* realPath = XMLString::replicate(fPath, fMemoryManager);
  603|      0|            ArrayJanitor<XMLCh> basePathName(realPath, fMemoryManager);
  604|       |
  605|       |            //
  606|       |            // Need to manually replace any character reference %xx first
  607|       |            // HTTP protocol will be done automatically by the netaccessor
  608|       |            //
  609|      0|            XMLSize_t end = XMLString::stringLen(realPath);
  610|      0|            int percentIndex = XMLString::indexOf(realPath, chPercent, 0, fMemoryManager);
  611|       |
  612|      0|            while (percentIndex != -1) {
  ------------------
  |  Branch (612:20): [True: 0, False: 0]
  ------------------
  613|       |
  614|       |            	// Isolate the length/boundary check so we don't try and copy off the end.
  615|      0|                if (percentIndex+2 >= (int)end)
  ------------------
  |  Branch (615:21): [True: 0, False: 0]
  ------------------
  616|      0|                {
  617|      0|                    XMLCh value1[3];
  618|      0|                    value1[1] = chNull;
  619|      0|                    value1[2] = chNull;
  620|      0|					XMLString::moveChars(value1, &(realPath[percentIndex]), (percentIndex + 1 >= (int)end ? 1 : 2));
  ------------------
  |  Branch (620:63): [True: 0, False: 0]
  ------------------
  621|      0|                    ThrowXMLwithMemMgr2(MalformedURLException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  622|      0|                            , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  623|      0|                            , realPath
  624|      0|                            , value1
  625|      0|                            , fMemoryManager);
  626|      0|                }
  627|      0|                else if (!isHexDigit(realPath[percentIndex+1]) || !isHexDigit(realPath[percentIndex+2]))
  ------------------
  |  Branch (627:26): [True: 0, False: 0]
  |  Branch (627:67): [True: 0, False: 0]
  ------------------
  628|      0|                {
  629|      0|                    XMLCh value1[4];
  630|      0|                    XMLString::moveChars(value1, &(realPath[percentIndex]), 3);
  631|      0|                    value1[3] = chNull;
  632|      0|                    ThrowXMLwithMemMgr2(MalformedURLException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  633|      0|                            , XMLExcepts::XMLNUM_URI_Component_Invalid_EscapeSequence
  634|      0|                            , realPath
  635|      0|                            , value1
  636|      0|                            , fMemoryManager);
  637|      0|                }
  638|       |
  639|      0|                unsigned int value = (xlatHexDigit(realPath[percentIndex+1]) * 16) + xlatHexDigit(realPath[percentIndex+2]);
  640|       |
  641|      0|                realPath[percentIndex] = XMLCh(value);
  642|       |
  643|      0|                XMLSize_t i =0;
  644|      0|                for (i = percentIndex + 1; i < end - 2 ; i++)
  ------------------
  |  Branch (644:44): [True: 0, False: 0]
  ------------------
  645|      0|                    realPath[i] = realPath[i+2];
  646|      0|                realPath[i] = chNull;
  647|      0|                end = i;
  648|       |
  649|      0|                if (((XMLSize_t)(percentIndex + 1)) < end)
  ------------------
  |  Branch (649:21): [True: 0, False: 0]
  ------------------
  650|      0|                  percentIndex = XMLString::indexOf(realPath, chPercent, percentIndex + 1, fMemoryManager);
  651|      0|                else
  652|      0|                  percentIndex = -1;
  653|      0|            }
  654|       |
  655|       |
  656|      0|            BinFileInputStream* retStrm = new (fMemoryManager) BinFileInputStream(realPath, fMemoryManager);
  657|      0|            if (!retStrm->getIsOpen())
  ------------------
  |  Branch (657:17): [True: 0, False: 0]
  ------------------
  658|      0|            {
  659|      0|                delete retStrm;
  660|      0|                return 0;
  661|      0|            }
  662|      0|            return retStrm;
  663|      0|        }
  664|      0|    }
  665|       |
  666|       |    //
  667|       |    //  If we don't have have an installed net accessor object, then we
  668|       |    //  have to just throw here.
  669|       |    //
  670|    150|    if (!XMLPlatformUtils::fgNetAccessor)
  ------------------
  |  Branch (670:9): [True: 0, False: 150]
  ------------------
  671|      0|        ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_UnsupportedProto, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  672|       |
  673|       |    // Else ask the net accessor to create the stream
  674|    150|    return XMLPlatformUtils::fgNetAccessor->makeNew(*this);
  675|    150|}
_ZN11xercesc_3_26XMLURL13buildFullTextEv:
  708|    150|{
  709|       |    // Calculate the worst case size of the buffer required
  710|    150|    XMLSize_t bufSize = gMaxProtoLen + 1
  711|    150|                           + XMLString::stringLen(fFragment) + 1
  712|    150|                           + XMLString::stringLen(fHost) + 2
  713|    150|                           + XMLString::stringLen(fPassword) + 1
  714|    150|                           + XMLString::stringLen(fPath)
  715|    150|                           + XMLString::stringLen(fQuery) + 1
  716|    150|                           + XMLString::stringLen(fUser) + 1
  717|    150|                           + 32;
  718|       |
  719|       |    // Clean up the existing buffer and allocate another
  720|    150|    fMemoryManager->deallocate(fURLText);//delete [] fURLText;
  721|    150|    fURLText = (XMLCh*) fMemoryManager->allocate((bufSize) * sizeof(XMLCh));//new XMLCh[bufSize];
  722|    150|    *fURLText = 0;
  723|       |
  724|    150|    XMLCh* outPtr = fURLText;
  725|    150|    if (fProtocol != Unknown)
  ------------------
  |  Branch (725:9): [True: 150, False: 0]
  ------------------
  726|    150|    {
  727|    150|        XMLString::catString(fURLText, getProtocolName());
  728|    150|        outPtr += XMLString::stringLen(fURLText);
  729|    150|        *outPtr++ = chColon;
  730|    150|        *outPtr++ = chForwardSlash;
  731|    150|        *outPtr++ = chForwardSlash;
  732|    150|    }
  733|       |
  734|    150|    if (fUser)
  ------------------
  |  Branch (734:9): [True: 80, False: 70]
  ------------------
  735|     80|    {
  736|     80|        XMLString::copyString(outPtr, fUser);
  737|     80|        outPtr += XMLString::stringLen(fUser);
  738|       |
  739|     80|        if (fPassword)
  ------------------
  |  Branch (739:13): [True: 26, False: 54]
  ------------------
  740|     26|        {
  741|     26|            *outPtr++ = chColon;
  742|     26|            XMLString::copyString(outPtr, fPassword);
  743|     26|            outPtr += XMLString::stringLen(fPassword);
  744|     26|        }
  745|       |
  746|     80|        *outPtr++ = chAt;
  747|     80|    }
  748|       |
  749|    150|    if (fHost)
  ------------------
  |  Branch (749:9): [True: 140, False: 10]
  ------------------
  750|    140|    {
  751|    140|        XMLString::copyString(outPtr, fHost);
  752|    140|        outPtr += XMLString::stringLen(fHost);
  753|       |
  754|       |        //
  755|       |        //  If the port is zero, then we don't put it in. Else we need
  756|       |        //  to because it was explicitly provided.
  757|       |        //
  758|    140|        if (fPortNum)
  ------------------
  |  Branch (758:13): [True: 105, False: 35]
  ------------------
  759|    105|        {
  760|    105|            *outPtr++ = chColon;
  761|       |
  762|    105|            XMLCh tmpBuf[17];
  763|    105|            XMLString::binToText(fPortNum, tmpBuf, 16, 10, fMemoryManager);
  764|    105|            XMLString::copyString(outPtr, tmpBuf);
  765|    105|            outPtr += XMLString::stringLen(tmpBuf);
  766|    105|        }
  767|    140|    }
  768|       |
  769|    150|    if (fPath)
  ------------------
  |  Branch (769:9): [True: 150, False: 0]
  ------------------
  770|    150|    {
  771|    150|        XMLString::copyString(outPtr, fPath);
  772|    150|        outPtr += XMLString::stringLen(fPath);
  773|    150|    }
  774|       |
  775|    150|    if (fQuery)
  ------------------
  |  Branch (775:9): [True: 21, False: 129]
  ------------------
  776|     21|    {
  777|     21|        *outPtr++ = chQuestion;
  778|     21|        XMLString::copyString(outPtr, fQuery);
  779|     21|        outPtr += XMLString::stringLen(fQuery);
  780|     21|    }
  781|       |
  782|    150|    if (fFragment)
  ------------------
  |  Branch (782:9): [True: 17, False: 133]
  ------------------
  783|     17|    {
  784|     17|        *outPtr++ = chPound;
  785|     17|        XMLString::copyString(outPtr, fFragment);
  786|     17|        outPtr += XMLString::stringLen(fFragment);
  787|     17|    }
  788|       |
  789|       |    // Cap it off in case the last op was not a string copy
  790|    150|    *outPtr = 0;
  791|    150|}
_ZN11xercesc_3_26XMLURL7cleanUpEv:
  799|  7.15k|{
  800|  7.15k|    fMemoryManager->deallocate(fFragment);//delete [] fFragment;
  801|  7.15k|    fMemoryManager->deallocate(fHost);//delete [] fHost;
  802|  7.15k|    fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  803|  7.15k|    fMemoryManager->deallocate(fPath);//delete [] fPath;
  804|  7.15k|    fMemoryManager->deallocate(fQuery);//delete [] fQuery;
  805|  7.15k|    fMemoryManager->deallocate(fUser);//delete [] fUser;
  806|  7.15k|    fMemoryManager->deallocate(fURLText);//delete [] fURLText;
  807|       |
  808|  7.15k|    fFragment = 0;
  809|  7.15k|    fHost = 0;
  810|  7.15k|    fPassword = 0;
  811|  7.15k|    fPath = 0;
  812|  7.15k|    fQuery = 0;
  813|  7.15k|    fUser = 0;
  814|  7.15k|    fURLText = 0;
  815|       |
  816|  7.15k|    fProtocol = Unknown;
  817|  7.15k|    fPortNum = 0;
  818|  7.15k|    fHasInvalidChar = false;
  819|  7.15k|}
_ZN11xercesc_3_26XMLURL20conglomerateWithBaseERKS0_b:
  827|  2.11k|{
  828|       |    // The base URL cannot be relative
  829|  2.11k|    if (baseURL.isRelative())
  ------------------
  |  Branch (829:9): [True: 2.11k, False: 0]
  ------------------
  830|  2.11k|    {
  831|  2.11k|        if (useExceptions)
  ------------------
  |  Branch (831:13): [True: 0, False: 2.11k]
  ------------------
  832|      0|			ThrowXMLwithMemMgr(MalformedURLException, XMLExcepts::URL_RelativeBaseURL, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  833|  2.11k|        else
  834|  2.11k|            return false;
  835|  2.11k|    }
  836|       |
  837|       |    //
  838|       |    //  Check a special case. If all we have is a fragment, then we want
  839|       |    //  to just take the base host and path, plus our fragment.
  840|       |    //
  841|      0|    if ((fProtocol == Unknown)
  ------------------
  |  Branch (841:9): [True: 0, False: 0]
  ------------------
  842|      0|    &&  !fHost
  ------------------
  |  Branch (842:9): [True: 0, False: 0]
  ------------------
  843|      0|    &&  !fPath
  ------------------
  |  Branch (843:9): [True: 0, False: 0]
  ------------------
  844|      0|    &&  fFragment)
  ------------------
  |  Branch (844:9): [True: 0, False: 0]
  ------------------
  845|      0|    {
  846|       |        // Just in case, make sure we don't leak the user or password values
  847|      0|        fMemoryManager->deallocate(fUser);//delete [] fUser;
  848|      0|        fUser = 0;
  849|      0|        fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  850|      0|        fPassword = 0;
  851|       |
  852|       |        // Copy over the protocol and port number as is
  853|      0|        fProtocol = baseURL.fProtocol;
  854|      0|        fPortNum = baseURL.fPortNum;
  855|       |
  856|       |        // Replicate the base fields that are provided
  857|      0|        fHost = XMLString::replicate(baseURL.fHost, fMemoryManager);
  858|      0|        fUser = XMLString::replicate(baseURL.fUser, fMemoryManager);
  859|      0|        fPassword = XMLString::replicate(baseURL.fPassword, fMemoryManager);
  860|      0|        fPath = XMLString::replicate(baseURL.fPath, fMemoryManager);
  861|      0|        return true;
  862|      0|    }
  863|       |
  864|       |    //
  865|       |    //  All we have to do is run up through our fields and, for each one
  866|       |    //  that we don't have, use the based URL's. Once we hit one field
  867|       |    //  that we have, we stop.
  868|       |    //
  869|      0|    if (fProtocol != Unknown)
  ------------------
  |  Branch (869:9): [True: 0, False: 0]
  ------------------
  870|      0|        return true;
  871|      0|    fProtocol = baseURL.fProtocol;
  872|       |
  873|       |    //
  874|       |    //  If the protocol is not file, and we either already have our own
  875|       |    //  host, or the base does not have one, then we are done.
  876|       |    //
  877|      0|    if (fProtocol != File)
  ------------------
  |  Branch (877:9): [True: 0, False: 0]
  ------------------
  878|      0|    {
  879|      0|        if (fHost || !baseURL.fHost)
  ------------------
  |  Branch (879:13): [True: 0, False: 0]
  |  Branch (879:22): [True: 0, False: 0]
  ------------------
  880|      0|            return true;
  881|      0|    }
  882|       |
  883|       |    // Replicate all of the hosty stuff if the base has one
  884|      0|    if (baseURL.fHost)
  ------------------
  |  Branch (884:9): [True: 0, False: 0]
  ------------------
  885|      0|    {
  886|       |        // Just in case, make sure we don't leak a user or password field
  887|      0|        fMemoryManager->deallocate(fUser);//delete [] fUser;
  888|      0|        fUser = 0;
  889|      0|        fMemoryManager->deallocate(fPassword);//delete [] fPassword;
  890|      0|        fPassword = 0;
  891|      0|        fMemoryManager->deallocate(fHost);//delete [] fHost;
  892|      0|        fHost = 0;
  893|       |
  894|      0|        fHost = XMLString::replicate(baseURL.fHost, fMemoryManager);
  895|      0|        fUser = XMLString::replicate(baseURL.fUser, fMemoryManager);
  896|      0|        fPassword = XMLString::replicate(baseURL.fPassword, fMemoryManager);
  897|       |
  898|      0|        fPortNum = baseURL.fPortNum;
  899|      0|    }
  900|       |
  901|       |    // If we have a path and its absolute, then we are done
  902|      0|    const bool hadPath = (fPath != 0);
  903|      0|    if (hadPath)
  ------------------
  |  Branch (903:9): [True: 0, False: 0]
  ------------------
  904|      0|    {
  905|      0|        if (*fPath == chForwardSlash)
  ------------------
  |  Branch (905:13): [True: 0, False: 0]
  ------------------
  906|      0|            return true;
  907|      0|    }
  908|       |
  909|       |    // Its a relative path, so weave them together.
  910|      0|    if (baseURL.fPath) {
  ------------------
  |  Branch (910:9): [True: 0, False: 0]
  ------------------
  911|      0|        XMLCh* temp = XMLPlatformUtils::weavePaths(baseURL.fPath, fPath ,fMemoryManager);
  912|      0|        fMemoryManager->deallocate(fPath);//delete [] fPath;
  913|      0|        fPath = temp;
  914|      0|    }
  915|       |
  916|       |    // If we had any original path, then we are done
  917|      0|    if (hadPath)
  ------------------
  |  Branch (917:9): [True: 0, False: 0]
  ------------------
  918|      0|        return true;
  919|       |
  920|       |    // We had no original path, so go on to deal with the query/fragment parts
  921|      0|    if (fQuery || !baseURL.fQuery)
  ------------------
  |  Branch (921:9): [True: 0, False: 0]
  |  Branch (921:19): [True: 0, False: 0]
  ------------------
  922|      0|        return true;
  923|      0|    fQuery = XMLString::replicate(baseURL.fQuery, fMemoryManager);
  924|       |
  925|      0|    if (fFragment || !baseURL.fFragment)
  ------------------
  |  Branch (925:9): [True: 0, False: 0]
  |  Branch (925:22): [True: 0, False: 0]
  ------------------
  926|      0|        return true;
  927|      0|    fFragment = XMLString::replicate(baseURL.fFragment, fMemoryManager);
  928|      0|	return true;
  929|      0|}
_ZN11xercesc_3_26XMLURL5parseEPKDsRS0_:
 1228|  4.51k|{
 1229|       |    // Simplify things by checking for the psycho scenarios first
 1230|  4.51k|    if (!*urlText)
  ------------------
  |  Branch (1230:9): [True: 1, False: 4.51k]
  ------------------
 1231|      1|        return false;
 1232|       |
 1233|       |    // Before we start, check if this urlText contains valid uri characters
 1234|  4.51k|    if (!XMLUri::isURIString(urlText))
  ------------------
  |  Branch (1234:9): [True: 367, False: 4.14k]
  ------------------
 1235|    367|        xmlURL.fHasInvalidChar = true;
 1236|  4.14k|    else
 1237|  4.14k|        xmlURL.fHasInvalidChar = false;
 1238|       |
 1239|       |    //
 1240|       |    //  The first thing we will do is to check for a file name, so that
 1241|       |    //  we don't waste time thinking its a URL. If its in the form x:\ or x:/
 1242|       |    //  and x is an ASCII letter, then assume that's the deal.
 1243|       |    //
 1244|  4.51k|    if (((*urlText >= chLatin_A) && (*urlText <= chLatin_Z))
  ------------------
  |  Branch (1244:10): [True: 4.39k, False: 122]
  |  Branch (1244:37): [True: 68, False: 4.32k]
  ------------------
 1245|  4.51k|    ||  ((*urlText >= chLatin_a) && (*urlText <= chLatin_z)))
  ------------------
  |  Branch (1245:10): [True: 4.31k, False: 127]
  |  Branch (1245:37): [True: 4.29k, False: 20]
  ------------------
 1246|  4.36k|    {
 1247|  4.36k|        if (*(urlText + 1) == chColon)
  ------------------
  |  Branch (1247:13): [True: 12, False: 4.35k]
  ------------------
 1248|     12|        {
 1249|     12|            if ((*(urlText + 2) == chForwardSlash)
  ------------------
  |  Branch (1249:17): [True: 1, False: 11]
  ------------------
 1250|     12|            ||  (*(urlText + 2) == chBackSlash))
  ------------------
  |  Branch (1250:17): [True: 1, False: 10]
  ------------------
 1251|      2|            {
 1252|      2|                return false;
 1253|      2|            }
 1254|     12|        }
 1255|  4.36k|    }
 1256|       |
 1257|       |    // Get a copy of the URL that we can modify
 1258|  4.51k|    XMLCh* srcCpy = XMLString::replicate(urlText, xmlURL.fMemoryManager);
 1259|  4.51k|    ArrayJanitor<XMLCh> janSrcCopy(srcCpy, xmlURL.fMemoryManager);
 1260|       |
 1261|       |    //
 1262|       |    //  Get a pointer now that we can run up thrown the source as we parse
 1263|       |    //  bits and pieces out of it.
 1264|       |    //
 1265|  4.51k|    XMLCh* srcPtr = srcCpy;
 1266|       |
 1267|       |    // Run up past any spaces
 1268|  4.76k|    while (*srcPtr)
  ------------------
  |  Branch (1268:12): [True: 4.76k, False: 1]
  ------------------
 1269|  4.76k|    {
 1270|  4.76k|        if (!XMLChar1_0::isWhitespace(*srcPtr))
  ------------------
  |  Branch (1270:13): [True: 4.51k, False: 250]
  ------------------
 1271|  4.51k|            break;
 1272|    250|        srcPtr++;
 1273|    250|    }
 1274|       |
 1275|       |    // Make sure it wasn't all space
 1276|  4.51k|    if (!*srcPtr)
  ------------------
  |  Branch (1276:9): [True: 1, False: 4.51k]
  ------------------
 1277|      1|        return false;
 1278|       |
 1279|       |    //
 1280|       |    //  Ok, the next thing we have to do is to find either a / or : character.
 1281|       |    //  If the : is first, we assume we have a protocol. If the / is first,
 1282|       |    //  then we skip to the host processing.
 1283|       |    //
 1284|  4.51k|    XMLCh* ptr1 = XMLString::findAny(srcPtr, gListOne);
 1285|  4.51k|    XMLCh* ptr2;
 1286|       |
 1287|       |    // If we found a protocol, then deal with it
 1288|  4.51k|    if (ptr1)
  ------------------
  |  Branch (1288:9): [True: 358, False: 4.15k]
  ------------------
 1289|    358|    {
 1290|    358|        if (*ptr1 == chColon)
  ------------------
  |  Branch (1290:13): [True: 264, False: 94]
  ------------------
 1291|    264|        {
 1292|       |            // Cap the string at the colon
 1293|    264|            *ptr1 = 0;
 1294|       |
 1295|       |            // And try to find it in our list of protocols
 1296|    264|            xmlURL.fProtocol = lookupByName(srcPtr);
 1297|       |
 1298|    264|            if (xmlURL.fProtocol == Unknown)
  ------------------
  |  Branch (1298:17): [True: 42, False: 222]
  ------------------
 1299|     42|                return false;
 1300|       |
 1301|       |            // And move our source pointer up past what we've processed
 1302|    222|            srcPtr = (ptr1 + 1);
 1303|    222|        }
 1304|    358|    }
 1305|       |
 1306|       |    //
 1307|       |    //  Ok, next we need to see if we have any host part. If the next
 1308|       |    //  two characters are //, then we need to check, else move on.
 1309|       |    //
 1310|  4.46k|    if ((*srcPtr == chForwardSlash) && (*(srcPtr + 1) == chForwardSlash))
  ------------------
  |  Branch (1310:9): [True: 304, False: 4.16k]
  |  Branch (1310:40): [True: 252, False: 52]
  ------------------
 1311|    252|    {
 1312|       |        // Move up past the slashes
 1313|    252|        srcPtr += 2;
 1314|       |
 1315|       |        //
 1316|       |        //  If we aren't at the end of the string, then there has to be a
 1317|       |        //  host part at this point. we will just look for the next / char
 1318|       |        //  or end of string and make all of that the host for now.
 1319|       |        //
 1320|    252|        if (*srcPtr)
  ------------------
  |  Branch (1320:13): [True: 251, False: 1]
  ------------------
 1321|    251|        {
 1322|       |            // Search from here for a / character
 1323|    251|            ptr1 = XMLString::findAny(srcPtr, gListFour);
 1324|       |
 1325|       |            //
 1326|       |            //  If we found something, then the host is between where
 1327|       |            //  we are and what we found. Else the host is the rest of
 1328|       |            //  the content and we are done. If its empty, leave it null.
 1329|       |            //
 1330|    251|            if (ptr1)
  ------------------
  |  Branch (1330:17): [True: 146, False: 105]
  ------------------
 1331|    146|            {
 1332|    146|                if (ptr1 != srcPtr)
  ------------------
  |  Branch (1332:21): [True: 131, False: 15]
  ------------------
 1333|    131|                {
 1334|    131|                    xmlURL.fHost = (XMLCh*) xmlURL.fMemoryManager->allocate
 1335|    131|                    (
 1336|    131|                        ((ptr1 - srcPtr) + 1) * sizeof(XMLCh)
 1337|    131|                    );//new XMLCh[(ptr1 - srcPtr) + 1];
 1338|    131|                    ptr2 = xmlURL.fHost;
 1339|  6.34M|                    while (srcPtr < ptr1)
  ------------------
  |  Branch (1339:28): [True: 6.34M, False: 131]
  ------------------
 1340|  6.34M|                        *ptr2++ = *srcPtr++;
 1341|    131|                    *ptr2 = 0;
 1342|    131|                }
 1343|    146|            }
 1344|    105|             else
 1345|    105|            {
 1346|    105|                xmlURL.fHost = XMLString::replicate(srcPtr, xmlURL.fMemoryManager);
 1347|       |
 1348|       |                // Update source pointer to the end
 1349|    105|                srcPtr += XMLString::stringLen(xmlURL.fHost);
 1350|    105|            }
 1351|    251|        }
 1352|    252|    }
 1353|  4.21k|    else
 1354|  4.21k|    {
 1355|       |        //
 1356|       |        // http protocol requires two forward slashes
 1357|       |        // we didn't get them, so throw an exception
 1358|       |        //
 1359|  4.21k|        if (xmlURL.fProtocol == HTTP)
  ------------------
  |  Branch (1359:13): [True: 3, False: 4.21k]
  ------------------
 1360|      3|            return false;
 1361|  4.21k|    }
 1362|       |
 1363|       |    //
 1364|       |    //  If there was a host part, then we have to grovel through it for
 1365|       |    //  all the bits and pieces it can hold.
 1366|       |    //
 1367|  4.46k|    if (xmlURL.fHost)
  ------------------
  |  Branch (1367:9): [True: 236, False: 4.23k]
  ------------------
 1368|    236|    {
 1369|       |        //
 1370|       |        //  Look for a '@' character, which indicates a user name. If we
 1371|       |        //  find one, then everything between the start of the host data
 1372|       |        //  and the character is the user name.
 1373|       |        //
 1374|    236|        ptr1 = XMLString::findAny(xmlURL.fHost, gListTwo);
 1375|    236|        if (ptr1)
  ------------------
  |  Branch (1375:13): [True: 85, False: 151]
  ------------------
 1376|     85|        {
 1377|       |            // Get this info out as the user name
 1378|     85|            *ptr1 = 0;
 1379|     85|            xmlURL.fUser = XMLString::replicate(xmlURL.fHost, xmlURL.fMemoryManager);
 1380|     85|            ptr1++;
 1381|       |
 1382|       |            // And now cut these chars from the host string
 1383|     85|            XMLString::cut(xmlURL.fHost, ptr1 - xmlURL.fHost);
 1384|       |
 1385|       |            // Is there a password inside the user string?
 1386|     85|            ptr2 = XMLString::findAny(xmlURL.fUser, gListThree);
 1387|     85|            if (ptr2)
  ------------------
  |  Branch (1387:17): [True: 28, False: 57]
  ------------------
 1388|     28|            {
 1389|       |                // Remove it from the user name string
 1390|     28|                *ptr2 = 0;
 1391|       |
 1392|       |                // And copy out the remainder to the password field
 1393|     28|                ptr2++;
 1394|     28|                xmlURL.fPassword = XMLString::replicate(ptr2, xmlURL.fMemoryManager);
 1395|     28|            }
 1396|     85|        }
 1397|       |
 1398|       |        //
 1399|       |        //  Ok, so now we are at the actual host name, if any. If we are
 1400|       |        //  not at the end of the host data, then lets see if we have a
 1401|       |        //  port trailing the
 1402|       |        //
 1403|    236|        ptr1 = XMLString::findAny(xmlURL.fHost, gListThree);
 1404|    236|        if (ptr1)
  ------------------
  |  Branch (1404:13): [True: 184, False: 52]
  ------------------
 1405|    184|        {
 1406|       |            // Remove it from the host name
 1407|    184|            *ptr1 = 0;
 1408|       |
 1409|       |            // Try to convert it to a numeric port value and store it
 1410|    184|            ptr1++;
 1411|    184|            if (!XMLString::textToBin(ptr1, xmlURL.fPortNum, xmlURL.fMemoryManager))
  ------------------
  |  Branch (1411:17): [True: 71, False: 113]
  ------------------
 1412|     71|                return false;
 1413|    184|        }
 1414|       |
 1415|       |        // If the host ended up empty, then toss is
 1416|    165|        if (!*(xmlURL.fHost))
  ------------------
  |  Branch (1416:13): [True: 3, False: 162]
  ------------------
 1417|      3|        {
 1418|      3|            xmlURL.fMemoryManager->deallocate(xmlURL.fHost);//delete[] fHost;
 1419|      3|            xmlURL.fHost = 0;
 1420|      3|        }
 1421|    165|    }
 1422|       |
 1423|       |    // If we are at the end, then we are done now
 1424|  4.39k|    if (!*srcPtr) {
  ------------------
  |  Branch (1424:9): [True: 88, False: 4.30k]
  ------------------
 1425|     88|        if(xmlURL.fHost) {
  ------------------
  |  Branch (1425:12): [True: 86, False: 2]
  ------------------
 1426|     86|            static const XMLCh slash[] = { chForwardSlash, chNull };
 1427|     86|            xmlURL.fPath = XMLString::replicate(slash, xmlURL.fMemoryManager);
 1428|     86|        }
 1429|     88|        return true;
 1430|     88|    }
 1431|       |
 1432|       |    //
 1433|       |    //  Next is the path part. It can be absolute, i.e. starting with a
 1434|       |    //  forward slash character, or relative. Its basically everything up
 1435|       |    //  to the end of the string or to any trailing query or fragment.
 1436|       |    //
 1437|  4.30k|    ptr1 = XMLString::findAny(srcPtr, gListFive);
 1438|  4.30k|    if (!ptr1)
  ------------------
  |  Branch (1438:9): [True: 4.21k, False: 95]
  ------------------
 1439|  4.21k|    {
 1440|  4.21k|        xmlURL.fPath = XMLString::replicate(srcPtr, xmlURL.fMemoryManager);
 1441|  4.21k|        return true;
 1442|  4.21k|    }
 1443|       |
 1444|       |    // Everything from where we are to what we found is the path
 1445|     95|    if (ptr1 > srcPtr)
  ------------------
  |  Branch (1445:9): [True: 84, False: 11]
  ------------------
 1446|     84|    {
 1447|     84|        xmlURL.fPath = (XMLCh*) xmlURL.fMemoryManager->allocate
 1448|     84|        (
 1449|     84|            ((ptr1 - srcPtr) + 1) * sizeof(XMLCh)
 1450|     84|        );//new XMLCh[(ptr1 - srcPtr) + 1];
 1451|     84|        ptr2 = xmlURL.fPath;
 1452|  4.50k|        while (srcPtr < ptr1)
  ------------------
  |  Branch (1452:16): [True: 4.41k, False: 84]
  ------------------
 1453|  4.41k|            *ptr2++ = *srcPtr++;
 1454|     84|        *ptr2 = 0;
 1455|     84|    }
 1456|       |
 1457|       |    //
 1458|       |    //  If we found a fragment, then it is the rest of the string and we
 1459|       |    //  are done.
 1460|       |    //
 1461|     95|    if (*srcPtr == chPound)
  ------------------
  |  Branch (1461:9): [True: 24, False: 71]
  ------------------
 1462|     24|    {
 1463|     24|        srcPtr++;
 1464|     24|        xmlURL.fFragment = XMLString::replicate(srcPtr, xmlURL.fMemoryManager);
 1465|     24|        return true;
 1466|     24|    }
 1467|       |
 1468|       |    //
 1469|       |    //  The query is either the rest of the string, or up to the fragment
 1470|       |    //  separator.
 1471|       |    //
 1472|     71|    srcPtr++;
 1473|     71|    ptr1 = XMLString::findAny(srcPtr, gListSix);
 1474|     71|    if (!ptr1)
  ------------------
  |  Branch (1474:9): [True: 31, False: 40]
  ------------------
 1475|     31|    {
 1476|     31|        xmlURL.fQuery = XMLString::replicate(srcPtr, xmlURL.fMemoryManager);
 1477|     31|        return true;
 1478|     31|    }
 1479|     40|     else
 1480|     40|    {
 1481|     40|        xmlURL.fQuery = (XMLCh*) xmlURL.fMemoryManager->allocate
 1482|     40|        (
 1483|     40|            ((ptr1 - srcPtr) + 1) * sizeof(XMLCh)
 1484|     40|        );//new XMLCh[(ptr1 - srcPtr) + 1];
 1485|     40|        ptr2 = xmlURL.fQuery;
 1486|  5.06k|        while (srcPtr < ptr1)
  ------------------
  |  Branch (1486:16): [True: 5.02k, False: 40]
  ------------------
 1487|  5.02k|            *ptr2++ = *srcPtr++;
 1488|     40|        *ptr2 = 0;
 1489|     40|    }
 1490|       |
 1491|       |    // If we are not at the end now, then everything else is the fragment
 1492|     40|    if (*srcPtr == chPound)
  ------------------
  |  Branch (1492:9): [True: 33, False: 7]
  ------------------
 1493|     33|    {
 1494|     33|        srcPtr++;
 1495|     33|        xmlURL.fFragment = XMLString::replicate(srcPtr, xmlURL.fMemoryManager);
 1496|     33|    }
 1497|       |
 1498|     40|    return true;
 1499|     71|}

_ZNK11xercesc_3_26XMLURL7getHostEv:
  240|    139|{
  241|    139|    return fHost;
  242|    139|}
_ZNK11xercesc_3_26XMLURL11getProtocolEv:
  255|    150|{
  256|    150|    return fProtocol;
  257|    150|}
_ZNK11xercesc_3_26XMLURL10getURLTextEv:
  270|    159|{
  271|       |    //
  272|       |    //  Fault it in if not already. Since this is a const method and we
  273|       |    //  can't use mutable members due the compilers we have to support,
  274|       |    //  we have to cast off the constness.
  275|       |    //
  276|    159|    if (!fURLText)
  ------------------
  |  Branch (276:9): [True: 150, False: 9]
  ------------------
  277|    150|        ((XMLURL*)this)->buildFullText();
  278|       |
  279|    159|    return fURLText;
  280|    159|}
_ZNK11xercesc_3_26XMLURL16getMemoryManagerEv:
  283|    428|{
  284|    428|    return fMemoryManager;
  285|    428|}

_ZN11xercesc_3_218XMLUTF16TranscoderC2EPKDsmbPNS_13MemoryManagerE:
   41|     25|{
   42|     25|}
_ZN11xercesc_3_218XMLUTF16TranscoderD2Ev:
   46|     25|{
   47|     25|}
_ZN11xercesc_3_218XMLUTF16Transcoder13transcodeFromEPKhmPDsmRmPh:
   60|     25|{
   61|       |    //
   62|       |    //  Calculate the max chars we can do here. Its the lesser of the
   63|       |    //  max output chars and the number of chars in the source.
   64|       |    //
   65|     25|    const XMLSize_t srcChars = srcCount / sizeof(UTF16Ch);
   66|     25|    const XMLSize_t countToDo = srcChars < maxChars ? srcChars : maxChars;
  ------------------
  |  Branch (66:33): [True: 20, False: 5]
  ------------------
   67|       |
   68|       |    // Look at the source data as UTF16 chars
   69|     25|    const UTF16Ch* asUTF16 = reinterpret_cast<const UTF16Ch*>(srcData);
   70|       |
   71|       |    // And get a mutable pointer to the output
   72|     25|    XMLCh* outPtr = toFill;
   73|       |
   74|       |    //
   75|       |    //  If its swapped, we have to do a char by char swap and cast. Else
   76|       |    //  we have to check whether our XMLCh and UTF16Ch types are the same
   77|       |    //  size or not. If so, we can optimize by just doing a buffer copy.
   78|       |    //
   79|     25|    if (fSwapped)
  ------------------
  |  Branch (79:9): [True: 14, False: 11]
  ------------------
   80|     14|    {
   81|       |        //
   82|       |        //  And then do the swapping loop for the count we precalculated. Note
   83|       |        //  that this also handles size conversion as well if XMLCh is not the
   84|       |        //  same size as UTF16Ch.
   85|       |        //
   86|  3.69k|        for (XMLSize_t index = 0; index < countToDo; index++)
  ------------------
  |  Branch (86:35): [True: 3.67k, False: 14]
  ------------------
   87|  3.67k|            *outPtr++ = BitOps::swapBytes(*asUTF16++);
   88|     14|    }
   89|     11|     else
   90|     11|    {
   91|       |        //
   92|       |        //  If the XMLCh type is the same size as a UTF16 value on this
   93|       |        //  platform, then we can do just a buffer copy straight to the target
   94|       |        //  buffer since our source chars are UTF-16 chars. If its not, then
   95|       |        //  we still have to do a loop and assign each one, in order to
   96|       |        //  implicitly convert.
   97|       |        //
   98|     11|        if (sizeof(XMLCh) == sizeof(UTF16Ch))
  ------------------
  |  Branch (98:13): [Folded - Ignored]
  ------------------
   99|     11|        {
  100|       |            //  Notice we convert char count to byte count here!!!
  101|     11|            memcpy(toFill, srcData, countToDo * sizeof(UTF16Ch));
  102|     11|        }
  103|      0|         else
  104|      0|        {
  105|      0|            for (XMLSize_t index = 0; index < countToDo; index++)
  ------------------
  |  Branch (105:39): [True: 0, False: 0]
  ------------------
  106|      0|                *outPtr++ = XMLCh(*asUTF16++);
  107|      0|        }
  108|     11|    }
  109|       |
  110|       |    // Set the bytes eaten
  111|     25|    bytesEaten = countToDo * sizeof(UTF16Ch);
  112|       |
  113|       |    // Set the character sizes to the fixed size
  114|     25|    memset(charSizes, sizeof(UTF16Ch), countToDo);
  115|       |
  116|       |    // Return the chars we transcoded
  117|     25|    return countToDo;
  118|     25|}

_ZN11xercesc_3_217XMLUTF8TranscoderC2EPKDsmPNS_13MemoryManagerE:
  104|    964|{
  105|    964|}
_ZN11xercesc_3_217XMLUTF8TranscoderD2Ev:
  108|    964|{
  109|    964|}
_ZN11xercesc_3_217XMLUTF8Transcoder13transcodeFromEPKhmPDsmRmPh:
  122|  5.48k|{
  123|       |    // Watch for pathological scenario. Shouldn't happen, but...
  124|  5.48k|    if (!srcCount || !maxChars)
  ------------------
  |  Branch (124:9): [True: 0, False: 5.48k]
  |  Branch (124:22): [True: 0, False: 5.48k]
  ------------------
  125|      0|        return 0;
  126|       |
  127|       |    //
  128|       |    //  Get pointers to our start and end points of the input and output
  129|       |    //  buffers.
  130|       |    //
  131|  5.48k|    const XMLByte*  srcPtr = srcData;
  132|  5.48k|    const XMLByte*  srcEnd = srcPtr + srcCount;
  133|  5.48k|    XMLCh*          outPtr = toFill;
  134|  5.48k|    XMLCh*          outEnd = outPtr + maxChars;
  135|  5.48k|    unsigned char*  sizePtr = charSizes;
  136|       |
  137|       |
  138|       |
  139|       |    //
  140|       |    //  We now loop until we either run out of input data, or room to store
  141|       |    //  output chars.
  142|       |    //
  143|  13.6k|    while ((srcPtr < srcEnd) && (outPtr < outEnd))
  ------------------
  |  Branch (143:12): [True: 13.6k, False: 2]
  |  Branch (143:33): [True: 13.6k, False: 3]
  ------------------
  144|  13.6k|    {
  145|       |        // Special-case ASCII, which is a leading byte value of <= 127
  146|  13.6k|        if (*srcPtr <= 127)
  ------------------
  |  Branch (146:13): [True: 9.82k, False: 3.83k]
  ------------------
  147|  9.82k|        {
  148|       |            // Handle ASCII in groups instead of single character at a time.
  149|  9.82k|            const XMLByte* srcPtr_save = srcPtr;
  150|  9.82k|            const XMLSize_t chunkSize = (srcEnd-srcPtr)<(outEnd-outPtr)?(srcEnd-srcPtr):(outEnd-outPtr);
  ------------------
  |  Branch (150:41): [True: 6.24k, False: 3.57k]
  ------------------
  151|  27.1M|            for(XMLSize_t i=0;i<chunkSize && *srcPtr <= 127;++i)
  ------------------
  |  Branch (151:31): [True: 27.1M, False: 2.16k]
  |  Branch (151:46): [True: 27.1M, False: 7.66k]
  ------------------
  152|  27.1M|                *outPtr++ = XMLCh(*srcPtr++);
  153|  9.82k|            memset(sizePtr,1,srcPtr - srcPtr_save);
  154|  9.82k|            sizePtr += srcPtr - srcPtr_save;
  155|  9.82k|            if (srcPtr == srcEnd || outPtr == outEnd)
  ------------------
  |  Branch (155:17): [True: 1.06k, False: 8.75k]
  |  Branch (155:37): [True: 1.09k, False: 7.66k]
  ------------------
  156|  2.16k|                break;
  157|  9.82k|        }
  158|       |
  159|       |        // See how many trailing src bytes this sequence is going to require
  160|  11.4k|        const unsigned int trailingBytes = gUTFBytes[*srcPtr];
  161|       |
  162|       |        //
  163|       |        //  If there are not enough source bytes to do this one, then we
  164|       |        //  are done. Note that we done >= here because we are implicitly
  165|       |        //  counting the 1 byte we get no matter what.
  166|       |        //
  167|       |        //  If we break out here, then there is nothing to undo since we
  168|       |        //  haven't updated any pointers yet.
  169|       |        //
  170|  11.4k|        if (srcPtr + trailingBytes >= srcEnd)
  ------------------
  |  Branch (170:13): [True: 43, False: 11.4k]
  ------------------
  171|     43|            break;
  172|       |
  173|       |        // Looks ok, so lets build up the value
  174|       |        // or at least let's try to do so--remembering that
  175|       |        // we cannot assume the encoding to be valid:
  176|       |
  177|       |        // first, test first byte
  178|  11.4k|        if((gUTFByteIndicatorTest[trailingBytes] & *srcPtr) != gUTFByteIndicator[trailingBytes]) {
  ------------------
  |  Branch (178:12): [True: 33, False: 11.4k]
  ------------------
  179|     33|            char pos[2] = {(char)0x31, 0}; 
  180|     33|            char len[2] = {(char)(trailingBytes+0x31), 0};
  181|     33|            char byte[2] = {(char)*srcPtr,0};
  182|     33|            ThrowXMLwithMemMgr3(UTFDataFormatException, XMLExcepts::UTF8_FormatError, pos, byte, len, getMemoryManager());
  ------------------
  |  |  270|     33|#define ThrowXMLwithMemMgr3(type,code,p1,p2,p3,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, 0, memMgr)
  ------------------
  183|     33|        }
  184|       |
  185|       |        /***
  186|       |         * http://www.unicode.org/reports/tr27/
  187|       |         *
  188|       |         * Table 3.1B. lists all of the byte sequences that are legal in UTF-8. 
  189|       |         * A range of byte values such as A0..BF indicates that any byte from A0 to BF (inclusive) 
  190|       |         * is legal in that position. 
  191|       |         * Any byte value outside of the ranges listed is illegal. 
  192|       |         * For example, 
  193|       |         * the byte sequence <C0 AF> is illegal  since C0 is not legal in the 1st Byte column. 
  194|       |         * The byte sequence <E0 9F 80> is illegal since in the row 
  195|       |         *    where E0 is legal as a first byte, 
  196|       |         *    9F is not legal as a second byte. 
  197|       |         * The byte sequence <F4 80 83 92> is legal, since every byte in that sequence matches 
  198|       |         * a byte range in a row of the table (the last row). 
  199|       |         *
  200|       |         *
  201|       |         * Table 3.1B. Legal UTF-8 Byte Sequences  
  202|       |         * Code Points              1st Byte    2nd Byte    3rd Byte    4th Byte 
  203|       |         * =========================================================================
  204|       |         * U+0000..U+007F            00..7F       
  205|       |         * -------------------------------------------------------------------------
  206|       |         * U+0080..U+07FF            C2..DF      80..BF      
  207|       |         *
  208|       |         * -------------------------------------------------------------------------
  209|       |         * U+0800..U+0FFF            E0          A0..BF     80..BF   
  210|       |         *                                       -- 
  211|       |         *                          
  212|       |         * U+1000..U+FFFF            E1..EF      80..BF     80..BF    
  213|       |         *
  214|       |         * --------------------------------------------------------------------------
  215|       |         * U+10000..U+3FFFF          F0          90..BF     80..BF       80..BF 
  216|       |         *                                       --
  217|       |         * U+40000..U+FFFFF          F1..F3      80..BF     80..BF       80..BF 
  218|       |         * U+100000..U+10FFFF        F4          80..8F     80..BF       80..BF 
  219|       |         *                                           --
  220|       |         * ==========================================================================
  221|       |         *
  222|       |         *  Cases where a trailing byte range is not 80..BF are underlined in the table to 
  223|       |         *  draw attention to them. These occur only in the second byte of a sequence.
  224|       |         *
  225|       |         ***/
  226|       |
  227|  11.4k|        XMLUInt32 tmpVal = 0;
  228|       |
  229|  11.4k|        switch(trailingBytes)
  230|  11.4k|        {
  231|  1.88k|            case 1 :
  ------------------
  |  Branch (231:13): [True: 1.88k, False: 9.53k]
  ------------------
  232|       |                // UTF-8:   [110y yyyy] [10xx xxxx]
  233|       |                // Unicode: [0000 0yyy] [yyxx xxxx]
  234|       |                //
  235|       |                // 0xC0, 0xC1 has been filtered out             
  236|  1.88k|                checkTrailingBytes(*(srcPtr+1), 1, 1);
  237|       |
  238|  1.88k|                tmpVal = *srcPtr++;
  239|  1.88k|                tmpVal <<= 6;
  240|  1.88k|                tmpVal += *srcPtr++;
  241|       |
  242|  1.88k|                break;
  243|  1.74k|            case 2 :
  ------------------
  |  Branch (243:13): [True: 1.74k, False: 9.66k]
  ------------------
  244|       |                // UTF-8:   [1110 zzzz] [10yy yyyy] [10xx xxxx]
  245|       |                // Unicode: [zzzz yyyy] [yyxx xxxx]
  246|       |                //
  247|  1.74k|                if (( *srcPtr == 0xE0) && ( *(srcPtr+1) < 0xA0)) 
  ------------------
  |  Branch (247:21): [True: 224, False: 1.52k]
  |  Branch (247:43): [True: 15, False: 209]
  ------------------
  248|     15|                {
  249|     15|                    char byte0[2] = {(char)*srcPtr    ,0};
  250|     15|                    char byte1[2] = {(char)*(srcPtr+1),0};
  251|       |
  252|     15|                    ThrowXMLwithMemMgr2(UTFDataFormatException
  ------------------
  |  |  268|     15|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  253|     15|                                      , XMLExcepts::UTF8_Invalid_3BytesSeq
  254|     15|                                      , byte0
  255|     15|                                      , byte1
  256|     15|                                      , getMemoryManager());
  257|     15|                }
  258|       |
  259|  1.73k|                checkTrailingBytes(*(srcPtr+1), 2, 1);
  260|  1.73k|                checkTrailingBytes(*(srcPtr+2), 2, 2);
  261|       |
  262|       |                //
  263|       |                // D36 (a) UTF-8 is the Unicode Transformation Format that serializes 
  264|       |                //         a Unicode code point as a sequence of one to four bytes, 
  265|       |                //         as specified in Table 3.1, UTF-8 Bit Distribution.
  266|       |                //     (b) An illegal UTF-8 code unit sequence is any byte sequence that 
  267|       |                //         does not match the patterns listed in Table 3.1B, Legal UTF-8 
  268|       |                //         Byte Sequences.
  269|       |                //     (c) An irregular UTF-8 code unit sequence is a six-byte sequence 
  270|       |                //         where the first three bytes correspond to a high surrogate, 
  271|       |                //         and the next three bytes correspond to a low surrogate. 
  272|       |                //         As a consequence of C12, these irregular UTF-8 sequences shall 
  273|       |                //         not be generated by a conformant process. 
  274|       |                //
  275|       |                //irregular three bytes sequence
  276|       |                // that is zzzzyy matches leading surrogate tag 110110 or 
  277|       |                //                       trailing surrogate tag 110111
  278|       |                // *srcPtr=1110 1101 
  279|       |                // *(srcPtr+1)=1010 yyyy or 
  280|       |                // *(srcPtr+1)=1011 yyyy
  281|       |                //
  282|       |                // 0xED 1110 1101
  283|       |                // 0xA0 1010 0000
  284|       |
  285|  1.73k|                if ((*srcPtr == 0xED) && (*(srcPtr+1) >= 0xA0))
  ------------------
  |  Branch (285:21): [True: 366, False: 1.36k]
  |  Branch (285:42): [True: 7, False: 359]
  ------------------
  286|      7|                {
  287|      7|                    char byte0[2] = {(char)*srcPtr,    0};
  288|      7|                    char byte1[2] = {(char)*(srcPtr+1),0};
  289|       |
  290|      7|                     ThrowXMLwithMemMgr2(UTFDataFormatException
  ------------------
  |  |  268|      7|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  291|      7|                              , XMLExcepts::UTF8_Irregular_3BytesSeq
  292|      7|                              , byte0
  293|      7|                              , byte1
  294|      7|                              , getMemoryManager());
  295|      7|                }
  296|       |
  297|  1.72k|                tmpVal = *srcPtr++;
  298|  1.72k|                tmpVal <<= 6;
  299|  1.72k|                tmpVal += *srcPtr++;
  300|  1.72k|                tmpVal <<= 6;
  301|  1.72k|                tmpVal += *srcPtr++;
  302|       |
  303|  1.72k|                break;
  304|  7.77k|            case 3 : 
  ------------------
  |  Branch (304:13): [True: 7.77k, False: 3.64k]
  ------------------
  305|       |                // UTF-8:   [1111 0uuu] [10uu zzzz] [10yy yyyy] [10xx xxxx]*
  306|       |                // Unicode: [1101 10ww] [wwzz zzyy] (high surrogate)
  307|       |                //          [1101 11yy] [yyxx xxxx] (low surrogate)
  308|       |                //          * uuuuu = wwww + 1
  309|       |                //
  310|  7.77k|                if (((*srcPtr == 0xF0) && (*(srcPtr+1) < 0x90)) ||
  ------------------
  |  Branch (310:22): [True: 1.52k, False: 6.24k]
  |  Branch (310:43): [True: 16, False: 1.51k]
  ------------------
  311|  7.77k|                    ((*srcPtr == 0xF4) && (*(srcPtr+1) > 0x8F))  )
  ------------------
  |  Branch (311:22): [True: 951, False: 6.80k]
  |  Branch (311:43): [True: 9, False: 942]
  ------------------
  312|     25|                {
  313|     25|                    char byte0[2] = {(char)*srcPtr    ,0};
  314|     25|                    char byte1[2] = {(char)*(srcPtr+1),0};
  315|       |
  316|     25|                    ThrowXMLwithMemMgr2(UTFDataFormatException
  ------------------
  |  |  268|     25|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  317|     25|                                      , XMLExcepts::UTF8_Invalid_4BytesSeq
  318|     25|                                      , byte0
  319|     25|                                      , byte1
  320|     25|                                      , getMemoryManager());
  321|     25|                }
  322|       |
  323|  7.74k|                checkTrailingBytes(*(srcPtr+1), 3, 1);
  324|  7.74k|                checkTrailingBytes(*(srcPtr+2), 3, 2);
  325|  7.74k|                checkTrailingBytes(*(srcPtr+3), 3, 3);
  326|       |                
  327|  7.74k|                tmpVal = *srcPtr++;
  328|  7.74k|                tmpVal <<= 6;
  329|  7.74k|                tmpVal += *srcPtr++;
  330|  7.74k|                tmpVal <<= 6;
  331|  7.74k|                tmpVal += *srcPtr++;
  332|  7.74k|                tmpVal <<= 6;
  333|  7.74k|                tmpVal += *srcPtr++;
  334|       |
  335|  7.74k|                break;
  336|     12|            default: // trailingBytes > 3
  ------------------
  |  Branch (336:13): [True: 12, False: 11.4k]
  ------------------
  337|       |
  338|       |                /***
  339|       |                 * The definition of UTF-8 in Annex D of ISO/IEC 10646-1:2000 also allows 
  340|       |                 * for the use of five- and six-byte sequences to encode characters that 
  341|       |                 * are outside the range of the Unicode character set; those five- and 
  342|       |                 * six-byte sequences are illegal for the use of UTF-8 as a transformation 
  343|       |                 * of Unicode characters. ISO/IEC 10646 does not allow mapping of unpaired 
  344|       |                 * surrogates, nor U+FFFE and U+FFFF (but it does allow other noncharacters).
  345|       |                 ***/
  346|     12|                char len[2]  = {(char)(trailingBytes+0x31), 0};
  347|     12|                char byte[2] = {(char)*srcPtr,0};
  348|       |
  349|     12|                ThrowXMLwithMemMgr2(UTFDataFormatException
  ------------------
  |  |  268|     12|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  350|  7.77k|                                  , XMLExcepts::UTF8_Exceeds_BytesLimit
  351|  7.77k|                                  , byte
  352|  7.77k|                                  , len
  353|  7.77k|                                  , getMemoryManager());
  354|       |
  355|      0|                break;
  356|  11.4k|        }
  357|       |
  358|       |
  359|       |        // since trailingBytes comes from an array, this logic is redundant
  360|       |        //  default :
  361|       |        //      ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq);
  362|       |        //}
  363|  11.1k|        tmpVal -= gUTFOffsets[trailingBytes];
  364|       |
  365|       |        //
  366|       |        //  If it will fit into a single char, then put it in. Otherwise
  367|       |        //  encode it as a surrogate pair. If its not valid, use the
  368|       |        //  replacement char.
  369|       |        //
  370|  11.1k|        if (!(tmpVal & 0xFFFF0000))
  ------------------
  |  Branch (370:13): [True: 3.49k, False: 7.66k]
  ------------------
  371|  3.49k|        {
  372|  3.49k|            *sizePtr++ = trailingBytes + 1;
  373|  3.49k|            *outPtr++ = XMLCh(tmpVal);
  374|  3.49k|        }
  375|  7.66k|         else if (tmpVal > 0x10FFFF)
  ------------------
  |  Branch (375:19): [True: 2.93k, False: 4.73k]
  ------------------
  376|  2.93k|        {
  377|       |            //
  378|       |            //  If we've gotten more than 32 chars so far, then just break
  379|       |            //  out for now and lets process those. When we come back in
  380|       |            //  here again, we'll get no chars and throw an exception. This
  381|       |            //  way, the error will have a line and col number closer to
  382|       |            //  the real problem area.
  383|       |            //
  384|  2.93k|            if ((outPtr - toFill) > 32)
  ------------------
  |  Branch (384:17): [True: 2.91k, False: 17]
  ------------------
  385|  2.91k|                break;
  386|       |
  387|  2.93k|            ThrowXMLwithMemMgr(TranscodingException, XMLExcepts::Trans_BadSrcSeq, getMemoryManager());
  ------------------
  |  |  264|     17|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  388|  2.93k|        }
  389|  4.73k|         else
  390|  4.73k|        {
  391|       |            //
  392|       |            //  If we have enough room to store the leading and trailing
  393|       |            //  chars, then lets do it. Else, pretend this one never
  394|       |            //  happened, and leave it for the next time.
  395|       |            //
  396|  4.73k|            if (outPtr + 1 >= outEnd)
  ------------------
  |  Branch (396:17): [True: 47, False: 4.68k]
  ------------------
  397|     47|            {
  398|     47|                srcPtr -= (trailingBytes + 1);
  399|     47|                break;
  400|     47|            }
  401|       |
  402|       |            // Store the leading surrogate char
  403|  4.68k|            tmpVal -= 0x10000;
  404|  4.68k|            *sizePtr++ = trailingBytes + 1;
  405|  4.68k|            *outPtr++ = XMLCh((tmpVal >> 10) + 0xD800);
  406|       |
  407|       |            //
  408|       |            //  And then the trailing char. This one accounts for no
  409|       |            //  bytes eaten from the source, so set the char size for this
  410|       |            //  one to be zero.
  411|       |            //
  412|  4.68k|            *sizePtr++ = 0;
  413|  4.68k|            *outPtr++ = XMLCh((tmpVal & 0x3FF) + 0xDC00);
  414|  4.68k|        }
  415|  11.1k|    }
  416|       |
  417|       |    // Update the bytes eaten
  418|  5.17k|    bytesEaten = srcPtr - srcData;
  419|       |
  420|       |    // Return the characters read
  421|  5.17k|    return outPtr - toFill;
  422|  5.48k|}

_ZNK11xercesc_3_217XMLUTF8Transcoder18checkTrailingBytesEhjj:
  104|  28.4k|{
  105|       |
  106|  28.4k|    if((toCheck & 0xC0) != 0x80) 
  ------------------
  |  Branch (106:8): [True: 198, False: 28.2k]
  ------------------
  107|    198|    {
  108|    198|        char len[2]  = {(char)(trailingBytes+0x31), 0};
  109|    198|        char pos[2]  = {(char)(position+0x31), 0};
  110|    198|        char byte[2] = {(char)toCheck,0};
  111|    198|        ThrowXMLwithMemMgr3(UTFDataFormatException, XMLExcepts::UTF8_FormatError, pos, byte, len, getMemoryManager());
  ------------------
  |  |  270|    198|#define ThrowXMLwithMemMgr3(type,code,p1,p2,p3,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, 0, memMgr)
  ------------------
  112|    198|    }
  113|       |
  114|  28.4k|}

_ZN11xercesc_3_26XMLUri11isURIStringEPKDs:
 1619|  4.51k|{
 1620|  4.51k|	if (!uricString || !*uricString)
  ------------------
  |  Branch (1620:6): [True: 0, False: 4.51k]
  |  Branch (1620:21): [True: 0, False: 4.51k]
  ------------------
 1621|      0|        return false;
 1622|       |
 1623|  4.51k|    const XMLCh* tmpStr = uricString;
 1624|       |
 1625|   979k|    while (*tmpStr)
  ------------------
  |  Branch (1625:12): [True: 975k, False: 4.14k]
  ------------------
 1626|   975k|    {
 1627|   975k|        if (isReservedOrUnreservedCharacter(*tmpStr))
  ------------------
  |  Branch (1627:13): [True: 974k, False: 1.06k]
  ------------------
 1628|   974k|        {
 1629|   974k|            tmpStr++;
 1630|   974k|        }
 1631|  1.06k|        else if (*tmpStr == chPercent)               // '%'
  ------------------
  |  Branch (1631:18): [True: 788, False: 276]
  ------------------
 1632|    788|        {
 1633|    788|            if (XMLString::stringLen(tmpStr) >=3
  ------------------
  |  Branch (1633:17): [True: 786, False: 2]
  ------------------
 1634|    788|                && XMLString::isHex(*(tmpStr+1))     // 1st hex
  ------------------
  |  Branch (1634:20): [True: 710, False: 76]
  ------------------
 1635|    788|                && XMLString::isHex(*(tmpStr+2))  )  // 2nd hex
  ------------------
  |  Branch (1635:20): [True: 697, False: 13]
  ------------------
 1636|    697|            {
 1637|    697|                tmpStr+=3;
 1638|    697|            }
 1639|     91|            else
 1640|     91|            {
 1641|     91|                return false;
 1642|     91|            }
 1643|    788|        }
 1644|    276|        else
 1645|    276|        {
 1646|    276|            return false;
 1647|    276|        }
 1648|   975k|    }
 1649|       |
 1650|  4.14k|    return true;
 1651|  4.51k|}
_ZN11xercesc_3_26XMLUri12normalizeURIEPKDsRNS_9XMLBufferE:
 2546|  2.23k|{
 2547|  2.23k|    const XMLCh* pszSrc = systemURI;
 2548|       |
 2549|  2.23k|    normalizedURI.reset();
 2550|       |
 2551|  7.58M|    while (*pszSrc) {
  ------------------
  |  Branch (2551:12): [True: 7.58M, False: 2.23k]
  ------------------
 2552|       |
 2553|  7.58M|        if ((*(pszSrc) == chPercent)
  ------------------
  |  Branch (2553:13): [True: 8.91k, False: 7.57M]
  ------------------
 2554|  7.58M|        &&  (*(pszSrc+1) == chDigit_2)
  ------------------
  |  Branch (2554:13): [True: 7.39k, False: 1.52k]
  ------------------
 2555|  7.58M|        &&  (*(pszSrc+2) == chDigit_0))
  ------------------
  |  Branch (2555:13): [True: 6.86k, False: 529]
  ------------------
 2556|  6.86k|        {
 2557|  6.86k|            pszSrc += 3;
 2558|  6.86k|            normalizedURI.append(chSpace);
 2559|  6.86k|        }
 2560|  7.57M|        else
 2561|  7.57M|        {
 2562|  7.57M|            normalizedURI.append(*pszSrc);
 2563|  7.57M|            pszSrc++;
 2564|  7.57M|        }
 2565|  7.58M|    }
 2566|  2.23k|}

_ZN11xercesc_3_26XMLUri31isReservedOrUnreservedCharacterEDs:
  640|   975k|{
  641|   975k|   return (XMLString::isAlphaNum(theChar) ||
  ------------------
  |  Branch (641:12): [True: 897k, False: 77.5k]
  ------------------
  642|   975k|           XMLString::indexOf(MARK_OR_RESERVED_CHARACTERS, theChar) != -1);
  ------------------
  |  Branch (642:12): [True: 76.5k, False: 1.06k]
  ------------------
  643|   975k|}

_ZN11xercesc_3_27XMemorynwEm:
   34|  17.3k|{
   35|  17.3k|	size_t headerSize = XMLPlatformUtils::alignPointerForNewBlockAllocation(
   36|  17.3k|										sizeof(MemoryManager*));
   37|       |	
   38|  17.3k|    void* const block = XMLPlatformUtils::fgMemoryManager->allocate
   39|  17.3k|        (
   40|  17.3k|	        headerSize + size
   41|  17.3k|        );
   42|  17.3k|    *(MemoryManager**)block = XMLPlatformUtils::fgMemoryManager;
   43|       |
   44|  17.3k|    return (char*)block + headerSize;
   45|  17.3k|}
_ZN11xercesc_3_27XMemorynwEmPNS_13MemoryManagerE:
   62|  26.3M|{
   63|  26.3M|    assert(manager != 0);
   64|       |	
   65|      0|    size_t headerSize = XMLPlatformUtils::alignPointerForNewBlockAllocation(
   66|  26.3M|       sizeof(MemoryManager*));
   67|       |       
   68|  26.3M|    void* const block = manager->allocate(headerSize + size);
   69|  26.3M|    *(MemoryManager**)block = manager;
   70|       |
   71|  26.3M|    return (char*)block + headerSize;
   72|  26.3M|}
_ZN11xercesc_3_27XMemorydlEPv:
   80|  26.3M|{
   81|  26.3M|    if (p != 0)
  ------------------
  |  Branch (81:9): [True: 26.3M, False: 0]
  ------------------
   82|  26.3M|    {
   83|  26.3M|        size_t headerSize = XMLPlatformUtils::alignPointerForNewBlockAllocation(
   84|  26.3M|          sizeof(MemoryManager*));
   85|  26.3M|        void* const block = (char*)p - headerSize;
   86|       |
   87|  26.3M|        MemoryManager* const manager = *(MemoryManager**)block;
   88|  26.3M|        assert(manager != 0);
   89|      0|        manager->deallocate(block);
   90|  26.3M|    }
   91|  26.3M|}
_ZN11xercesc_3_27XMemorydlEPvPNS_13MemoryManagerE:
   97|    283|{
   98|    283|    assert(manager != 0);
   99|       |	
  100|    283|    if (p != 0)
  ------------------
  |  Branch (100:9): [True: 283, False: 0]
  ------------------
  101|    283|    {
  102|    283|        size_t headerSize = XMLPlatformUtils::alignPointerForNewBlockAllocation(sizeof(MemoryManager*));
  103|    283|        void* const block = (char*)p - headerSize;
  104|       |
  105|       |        /***
  106|       |         * assert(*(MemoryManager**)block == manager);                 
  107|       |         *
  108|       |         * NOTE: for compiler which can't properly trace the memory manager used in the 
  109|       |         *       placement new, we use the memory manager embedded in the memory rather 
  110|       |         *       than the one passed in
  111|       |         */ 
  112|    283|        MemoryManager* pM = *(MemoryManager**)block;
  113|    283|        pM->deallocate(block);
  114|    283|    }
  115|    283|}

_ZN11xercesc_3_27XMemoryC2Ev:
  131|  95.2M|    {
  132|  95.2M|    }

_ZN11xercesc_3_217ASCIIRangeFactoryC2Ev:
   37|      1|{
   38|      1|}
_ZN11xercesc_3_217ASCIIRangeFactory11buildRangesEPNS_13RangeTokenMapE:
   47|      1|void ASCIIRangeFactory::buildRanges(RangeTokenMap *rangeTokMap) {
   48|       |
   49|      1|    if (fRangesCreated)
  ------------------
  |  Branch (49:9): [True: 0, False: 1]
  ------------------
   50|      0|        return;
   51|       |
   52|      1|    if (!fKeywordsInitialized) {
  ------------------
  |  Branch (52:9): [True: 0, False: 1]
  ------------------
   53|      0|        initializeKeywordMap(rangeTokMap);
   54|      0|    }
   55|       |
   56|      1|    TokenFactory* tokFactory = rangeTokMap->getTokenFactory();
   57|       |
   58|       |    // Create space ranges
   59|      1|    RangeToken* tok = tokFactory->createRange();
   60|      1|    tok->addRange(chHTab, chHTab);
   61|      1|    tok->addRange(chLF, chLF);
   62|      1|    tok->addRange(chFF, chFF);
   63|      1|    tok->addRange(chCR, chCR);
   64|      1|    tok->addRange(chSpace, chSpace);
   65|       |
   66|       |    // Build the internal map.
   67|      1|    tok->createMap();
   68|       |
   69|      1|    rangeTokMap->setRangeToken(fgASCIISpace, tok);
   70|       |
   71|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
   72|       |
   73|       |    // Build the internal map.
   74|      1|    tok->createMap();
   75|       |
   76|      1|    rangeTokMap->setRangeToken(fgASCIISpace, tok , true);
   77|       |
   78|       |    // Create digits ranges
   79|      1|    tok = tokFactory->createRange();
   80|      1|    tok->addRange(chDigit_0, chDigit_9);
   81|       |
   82|       |    // Build the internal map.
   83|      1|    tok->createMap();
   84|       |
   85|      1|    rangeTokMap->setRangeToken(fgASCIIDigit, tok);
   86|       |
   87|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
   88|       |
   89|       |    // Build the internal map.
   90|      1|    tok->createMap();
   91|       |
   92|      1|    rangeTokMap->setRangeToken(fgASCIIDigit, tok , true);
   93|       |
   94|       |    // Create word ranges
   95|      1|    tok = tokFactory->createRange();
   96|      1|    tok->addRange(chDigit_0, chDigit_9);
   97|      1|    tok->addRange(chLatin_A, chLatin_Z);
   98|      1|    tok->addRange(chUnderscore, chUnderscore);
   99|      1|    tok->addRange(chLatin_a, chLatin_z);
  100|       |    // Build the internal map.
  101|      1|    tok->createMap();
  102|      1|    rangeTokMap->setRangeToken(fgASCIIWord, tok);
  103|       |
  104|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  105|       |    // Build the internal map.
  106|      1|    tok->createMap();
  107|      1|    rangeTokMap->setRangeToken(fgASCIIWord, tok , true);
  108|       |
  109|       |    // Create xdigit ranges
  110|      1|    tok = tokFactory->createRange();
  111|      1|    tok->addRange(chDigit_0, chDigit_9);
  112|      1|    tok->addRange(chLatin_A, chLatin_F);
  113|      1|    tok->addRange(chLatin_a, chLatin_a);
  114|       |    // Build the internal map.
  115|      1|    tok->createMap();
  116|       |
  117|      1|    rangeTokMap->setRangeToken(fgASCIIXDigit, tok);
  118|       |
  119|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  120|       |    // Build the internal map.
  121|      1|    tok->createMap();
  122|      1|    rangeTokMap->setRangeToken(fgASCIIXDigit, tok , true);
  123|       |
  124|       |    // Create ascii ranges
  125|      1|    tok = tokFactory->createRange();
  126|      1|    tok->addRange(0x00, 0x7F);
  127|       |    // Build the internal map.
  128|      1|    tok->createMap();
  129|      1|    rangeTokMap->setRangeToken(fgASCII, tok);
  130|       |
  131|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  132|       |    // Build the internal map.
  133|      1|    tok->createMap();
  134|      1|    rangeTokMap->setRangeToken(fgASCII, tok , true);
  135|       |
  136|      1|    fRangesCreated = true;
  137|      1|}
_ZN11xercesc_3_217ASCIIRangeFactory20initializeKeywordMapEPNS_13RangeTokenMapE:
  142|      1|void ASCIIRangeFactory::initializeKeywordMap(RangeTokenMap *rangeTokMap) {
  143|       |
  144|      1|    if (fKeywordsInitialized)
  ------------------
  |  Branch (144:9): [True: 0, False: 1]
  ------------------
  145|      0|        return;
  146|       |
  147|      1|    rangeTokMap->addKeywordMap(fgASCIISpace, fgASCIICategory);
  148|      1|    rangeTokMap->addKeywordMap(fgASCIIDigit, fgASCIICategory);
  149|      1|    rangeTokMap->addKeywordMap(fgASCIIWord, fgASCIICategory);
  150|      1|    rangeTokMap->addKeywordMap(fgASCIIXDigit, fgASCIICategory);
  151|      1|    rangeTokMap->addKeywordMap(fgASCII, fgASCIICategory);
  152|       |
  153|      1|    fKeywordsInitialized = true;
  154|      1|}

_ZN11xercesc_3_217BlockRangeFactoryC2Ev:
  297|      1|{
  298|       |
  299|      1|}
_ZN11xercesc_3_217BlockRangeFactory11buildRangesEPNS_13RangeTokenMapE:
  308|      1|void BlockRangeFactory::buildRanges(RangeTokenMap *rangeTokMap) {
  309|       |
  310|      1|    if (fRangesCreated)
  ------------------
  |  Branch (310:9): [True: 0, False: 1]
  ------------------
  311|      0|        return;
  312|       |
  313|      1|    if (!fKeywordsInitialized) {
  ------------------
  |  Branch (313:9): [True: 0, False: 1]
  ------------------
  314|      0|        initializeKeywordMap(rangeTokMap);
  315|      0|    }
  316|       |
  317|      1|    TokenFactory* tokFactory = rangeTokMap->getTokenFactory();
  318|       |
  319|       |    //for performance, once the desired specials and private use are found
  320|       |    //don't need to compareString anymore
  321|      1|    bool foundSpecial = false;
  322|      1|    bool foundPrivate = false;
  323|       |
  324|     94|    for (int i=0; i < BLOCKNAMESIZE; i++) {
  ------------------
  |  Branch (324:19): [True: 93, False: 1]
  ------------------
  325|     93|        RangeToken* tok = tokFactory->createRange();
  326|     93|        tok->addRange(blockRanges[i*2], blockRanges[(i*2)+1]);
  327|       |
  328|     93|        if (!foundSpecial && XMLString::equals((XMLCh*)fgBlockNames[i] , (XMLCh*) fgBlockIsSpecials)) {
  ------------------
  |  Branch (328:13): [True: 83, False: 10]
  |  Branch (328:30): [True: 1, False: 82]
  ------------------
  329|      1|            tok->addRange(0xFFF0, 0xFFFD);
  330|      1|            foundSpecial = true;
  331|      1|        }
  332|     93|        if (!foundPrivate && XMLString::equals((XMLCh*)fgBlockNames[i] , (XMLCh*) fgBlockIsPrivateUse)) {
  ------------------
  |  Branch (332:13): [True: 75, False: 18]
  |  Branch (332:30): [True: 1, False: 74]
  ------------------
  333|      1|            tok->addRange(0xF0000, 0xFFFFD);
  334|      1|            tok->addRange(0x100000, 0x10FFFD);
  335|      1|            foundPrivate = true;
  336|      1|        }
  337|       |
  338|       |        // Build the internal map.
  339|     93|        tok->createMap();
  340|     93|        rangeTokMap->setRangeToken(fgBlockNames[i], tok);
  341|     93|        tok = RangeToken::complementRanges(tok, tokFactory);
  342|       |        // Build the internal map.
  343|     93|        tok->createMap();
  344|     93|        rangeTokMap->setRangeToken(fgBlockNames[i], tok , true);
  345|     93|    }
  346|       |
  347|      1|    fRangesCreated = true;
  348|      1|}
_ZN11xercesc_3_217BlockRangeFactory20initializeKeywordMapEPNS_13RangeTokenMapE:
  353|      1|void BlockRangeFactory::initializeKeywordMap(RangeTokenMap *rangeTokMap) {
  354|       |
  355|      1|    if (fKeywordsInitialized)
  ------------------
  |  Branch (355:9): [True: 0, False: 1]
  ------------------
  356|      0|        return;
  357|       |
  358|     94|    for (int i=0; i< BLOCKNAMESIZE; i++) {
  ------------------
  |  Branch (358:19): [True: 93, False: 1]
  ------------------
  359|     93|        rangeTokMap->addKeywordMap(fgBlockNames[i], fgBlockCategory);
  360|     93|    }
  361|       |
  362|      1|    fKeywordsInitialized = true;
  363|      1|}

_ZN11xercesc_3_29CharTokenC2ENS_5Token7tokTypeEiPNS_13MemoryManagerE:
   35|      2|{
   36|       |
   37|      2|}

_ZNK11xercesc_3_29CharToken7getCharEv:
   68|      2|inline XMLInt32 CharToken::getChar() const {
   69|       |
   70|      2|    return fCharData;
   71|      2|}

_ZN11xercesc_3_212ClosureTokenC2ENS_5Token7tokTypeEPS1_PNS_13MemoryManagerE:
   37|      8|{
   38|       |
   39|      8|}

_ZNK11xercesc_3_212ClosureToken6getMaxEv:
   80|      8|inline int ClosureToken::getMax() const {
   81|       |
   82|      8|    return fMax;
   83|      8|}
_ZNK11xercesc_3_212ClosureToken6getMinEv:
   85|     20|inline int ClosureToken::getMin() const {
   86|       |
   87|     20|    return fMin;
   88|     20|}
_ZNK11xercesc_3_212ClosureToken8getChildEm:
   90|     12|inline Token* ClosureToken::getChild(const XMLSize_t) const {
   91|       |
   92|     12|    return fChild;
   93|     12|}
_ZN11xercesc_3_212ClosureToken6setMaxEi:
   98|      4|inline void ClosureToken::setMax(const int maxVal) {
   99|       |
  100|      4|    fMax = maxVal;
  101|      4|}
_ZN11xercesc_3_212ClosureToken6setMinEi:
  103|      4|inline void ClosureToken::setMin(const int minVal) {
  104|       |
  105|      4|    fMin = minVal;
  106|      4|}

_ZN11xercesc_3_211ConcatTokenC2EPNS_5TokenES2_PNS_13MemoryManagerE:
   36|      2|{
   37|       |
   38|      2|}

_ZNK11xercesc_3_211ConcatToken4sizeEv:
   65|      3|inline XMLSize_t ConcatToken::size() const {
   66|       |
   67|      3|    return 2;
   68|      3|}
_ZNK11xercesc_3_211ConcatToken8getChildEm:
   70|      6|inline Token* ConcatToken::getChild(const XMLSize_t index) const {
   71|       |
   72|      6|    return index == 0 ? fChild1 : fChild2;
  ------------------
  |  Branch (72:12): [True: 3, False: 3]
  ------------------
   73|      6|}

_ZN11xercesc_3_22OpC2ENS0_6opTypeEPNS_13MemoryManagerE:
   37|     72|{
   38|     72|}
_ZN11xercesc_3_26CharOpC2ENS_2Op6opTypeEiPNS_13MemoryManagerE:
   92|      2|      , fCharData(charData) {
   93|      2|}
_ZN11xercesc_3_27UnionOpC2ENS_2Op6opTypeEmPNS_13MemoryManagerE:
  108|      1|      , fBranches(new (manager) RefVectorOf<Op> (size, false, manager)) {
  109|       |
  110|      1|}
_ZNK11xercesc_3_27UnionOp7getSizeEv:
  115|     16|XMLSize_t UnionOp::getSize() const {
  116|       |
  117|     16|    return fBranches->size();
  118|     16|}
_ZNK11xercesc_3_27UnionOp9elementAtEm:
  120|     27|const Op* UnionOp::elementAt(XMLSize_t index) const {
  121|       |
  122|     27|    return fBranches->elementAt(index);
  123|     27|}
_ZN11xercesc_3_27UnionOp10addElementEPNS_2OpE:
  125|      2|void UnionOp::addElement(Op* const op) {
  126|       |
  127|      2|    fBranches->addElement(op);
  128|      2|}
_ZN11xercesc_3_27ChildOpC2ENS_2Op6opTypeEPNS_13MemoryManagerE:
  135|     32|      , fChild(0) {
  136|       |
  137|     32|}
_ZNK11xercesc_3_27ChildOp8getChildEv:
  142|    116|const Op* ChildOp::getChild() const {
  143|       |
  144|    116|    return fChild;
  145|    116|}
_ZN11xercesc_3_27ChildOp8setChildEPKNS_2OpE:
  147|     32|void ChildOp::setChild(const Op* const child) {
  148|       |
  149|     32|    fChild = child;
  150|     32|}
_ZN11xercesc_3_210ModifierOpC2ENS_2Op6opTypeEiiPNS_13MemoryManagerE:
  159|      4|      , fVal2(v2) {
  160|       |
  161|      4|}
_ZNK11xercesc_3_210ModifierOp7getDataEv:
  166|     16|XMLInt32 ModifierOp::getData() const {
  167|       |
  168|     16|    return fVal1;
  169|     16|}
_ZN11xercesc_3_27RangeOpC2ENS_2Op6opTypeEPKNS_5TokenEPNS_13MemoryManagerE:
  181|     37|      , fToken(token) {
  182|       |
  183|     37|}
_ZNK11xercesc_3_27RangeOp8getTokenEv:
  188|    132|const Token* RangeOp::getToken() const {
  189|       |
  190|    132|    return fToken;
  191|    132|}

_ZNK11xercesc_3_22Op9getOpTypeEv:
  277|    182|inline Op::opType Op::getOpType() const {
  278|       |
  279|    182|    return fOpType;
  280|    182|}
_ZNK11xercesc_3_22Op9getNextOpEv:
  282|    141|inline const Op* Op::getNextOp() const {
  283|       |
  284|    141|    return fNextOp;
  285|    141|}
_ZN11xercesc_3_22Op9setOpTypeENS0_6opTypeE:
  290|      4|inline void Op::setOpType(const Op::opType type) {
  291|       |
  292|      4|    fOpType = type;
  293|      4|}
_ZN11xercesc_3_22Op9setNextOpEPKS0_:
  295|     71|inline void Op::setNextOp(const Op* const nextOp) {
  296|       |    
  297|     71|    fNextOp = nextOp;
  298|     71|}

_ZN11xercesc_3_29OpFactoryC2EPNS_13MemoryManagerE:
   37|      4|{
   38|      4|    fOpVector = new (fMemoryManager) RefVectorOf<Op>(16, true, fMemoryManager);
   39|      4|}
_ZN11xercesc_3_29OpFactory12createCharOpEi:
   57|      2|CharOp* OpFactory::createCharOp(XMLInt32 data) {
   58|       |
   59|      2|    CharOp* tmpOp = new (fMemoryManager) CharOp(Op::O_CHAR, data, fMemoryManager);
   60|       |
   61|      2|    fOpVector->addElement(tmpOp);
   62|      2|    return tmpOp;
   63|      2|}
_ZN11xercesc_3_29OpFactory13createUnionOpEm:
   82|      1|UnionOp* OpFactory::createUnionOp(XMLSize_t size) {
   83|       |
   84|      1|    UnionOp* tmpOp = new (fMemoryManager) UnionOp(Op::O_UNION, size, fMemoryManager);
   85|       |
   86|      1|    fOpVector->addElement(tmpOp);
   87|      1|    return tmpOp;
   88|      1|}
_ZN11xercesc_3_29OpFactory15createClosureOpEi:
   90|      4|ChildOp* OpFactory::createClosureOp(int id) {
   91|       |
   92|      4|    ModifierOp* tmpOp = new (fMemoryManager) ModifierOp(Op::O_CLOSURE, id, -1, fMemoryManager);
   93|       |
   94|      4|    fOpVector->addElement(tmpOp);
   95|      4|    return tmpOp;
   96|      4|}
_ZN11xercesc_3_29OpFactory16createQuestionOpEb:
  106|     28|ChildOp* OpFactory::createQuestionOp(bool nonGreedy) {
  107|       |
  108|     28|    ChildOp* tmpOp = new (fMemoryManager)  ChildOp(nonGreedy ? Op::O_NONGREEDYQUESTION :
  ------------------
  |  Branch (108:52): [True: 0, False: 28]
  ------------------
  109|     28|                                             Op::O_QUESTION, fMemoryManager);
  110|       |
  111|     28|    fOpVector->addElement(tmpOp);
  112|     28|    return tmpOp;
  113|     28|}
_ZN11xercesc_3_29OpFactory13createRangeOpEPKNS_5TokenE:
  115|     37|RangeOp* OpFactory::createRangeOp(const Token* const token) {
  116|       |
  117|     37|    RangeOp* tmpOp = new (fMemoryManager)  RangeOp(Op::O_RANGE, token, fMemoryManager);
  118|       |    
  119|     37|    fOpVector->addElement(tmpOp);
  120|     37|    return tmpOp;
  121|     37|}

_ZN11xercesc_3_210ParenTokenC2ENS_5Token7tokTypeEPS1_iPNS_13MemoryManagerE:
   37|      4|{
   38|       |
   39|      4|}

_ZNK11xercesc_3_210ParenToken10getNoParenEv:
   71|      4|inline int ParenToken::getNoParen() const {
   72|       |
   73|      4|    return fNoParen;
   74|      4|}
_ZNK11xercesc_3_210ParenToken8getChildEm:
   76|      8|inline Token* ParenToken::getChild(const XMLSize_t) const {
   77|       |
   78|      8|    return fChild;
   79|      8|}

_ZN11xercesc_3_218ParserForXMLSchemaC2EPNS_13MemoryManagerE:
   41|      4|{
   42|       |
   43|      4|}
_ZN11xercesc_3_218ParserForXMLSchemaD2Ev:
   45|      4|ParserForXMLSchema::~ParserForXMLSchema() {
   46|       |
   47|      4|}
_ZN11xercesc_3_218ParserForXMLSchema11processPlusEPNS_5TokenE:
   66|      2|Token* ParserForXMLSchema::processPlus(Token* const tok) {
   67|       |
   68|       |    // XML Schema doesn't support reluctant quantifiers
   69|      2|    processNext();
   70|      2|    return getTokenFactory()->createConcat(tok,
   71|      2|                               getTokenFactory()->createClosure(tok));
   72|      2|}
_ZN11xercesc_3_218ParserForXMLSchema11processStarEPNS_5TokenE:
   74|      2|Token* ParserForXMLSchema::processStar(Token* const tok) {
   75|       |
   76|       |    // XML Schema doesn't support reluctant quantifiers
   77|      2|    processNext();
   78|      2|    return getTokenFactory()->createClosure(tok);
   79|      2|}
_ZN11xercesc_3_218ParserForXMLSchema15processQuestionEPNS_5TokenE:
   81|      1|Token* ParserForXMLSchema::processQuestion(Token* const tok) {
   82|       |
   83|       |    // XML Schema doesn't support reluctant quantifiers
   84|      1|    processNext();
   85|       |
   86|      1|    TokenFactory* tokFactory = getTokenFactory();
   87|      1|    Token* retTok = tokFactory->createUnion();
   88|      1|    retTok->addChild(tok, tokFactory);
   89|      1|    retTok->addChild(tokFactory->createToken(Token::T_EMPTY), tokFactory);
   90|      1|    return retTok;
   91|      1|}
_ZN11xercesc_3_218ParserForXMLSchema12processParenEv:
   93|      4|Token* ParserForXMLSchema::processParen() {
   94|       |
   95|       |    // XML Schema doesn't support back references
   96|      4|    processNext();
   97|      4|    Token* retTok = getTokenFactory()->createParenthesis(parseRegx(true), 0);
   98|       |
   99|      4|    if (getState() != REGX_T_RPAREN) {
  ------------------
  |  Branch (99:9): [True: 0, False: 4]
  ------------------
  100|      0|        ThrowXMLwithMemMgr(ParseException, XMLExcepts::Parser_Factor1, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  101|      0|    }
  102|       |
  103|      4|    processNext();
  104|      4|    return retTok;
  105|      4|}
_ZN11xercesc_3_218ParserForXMLSchema13checkQuestionEm:
  117|      4|bool ParserForXMLSchema::checkQuestion(const XMLSize_t ) {
  118|       |
  119|       |    // XML Schema doesn't support reluctant quantifiers
  120|      4|    return false;
  121|      4|}
_ZN11xercesc_3_218ParserForXMLSchema13decodeEscapedEv:
  124|      1|XMLInt32 ParserForXMLSchema::decodeEscaped() {
  125|       |
  126|       |    // XML Schema doesn't support an escaped "$"
  127|      1|    if (getState() != REGX_T_BACKSOLIDUS)
  ------------------
  |  Branch (127:9): [True: 0, False: 1]
  ------------------
  128|      0|        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  129|       |
  130|      1|    XMLInt32 ch = getCharData();
  131|       |
  132|      1|    switch (ch) {
  133|      0|    case chLatin_n:
  ------------------
  |  Branch (133:5): [True: 0, False: 1]
  ------------------
  134|      0|        ch = chLF;
  135|      0|        break;
  136|      0|    case chLatin_r:
  ------------------
  |  Branch (136:5): [True: 0, False: 1]
  ------------------
  137|      0|        ch = chCR;
  138|      0|        break;
  139|      0|    case chLatin_t:
  ------------------
  |  Branch (139:5): [True: 0, False: 1]
  ------------------
  140|      0|        ch = chHTab;
  141|      0|        break;
  142|      0|    case chBackSlash:
  ------------------
  |  Branch (142:5): [True: 0, False: 1]
  ------------------
  143|      0|    case chPipe:
  ------------------
  |  Branch (143:5): [True: 0, False: 1]
  ------------------
  144|      0|    case chPeriod:
  ------------------
  |  Branch (144:5): [True: 0, False: 1]
  ------------------
  145|      0|    case chCaret:
  ------------------
  |  Branch (145:5): [True: 0, False: 1]
  ------------------
  146|      1|    case chDash:
  ------------------
  |  Branch (146:5): [True: 1, False: 0]
  ------------------
  147|      1|    case chQuestion:
  ------------------
  |  Branch (147:5): [True: 0, False: 1]
  ------------------
  148|      1|    case chAsterisk:
  ------------------
  |  Branch (148:5): [True: 0, False: 1]
  ------------------
  149|      1|    case chPlus:
  ------------------
  |  Branch (149:5): [True: 0, False: 1]
  ------------------
  150|      1|    case chOpenCurly:
  ------------------
  |  Branch (150:5): [True: 0, False: 1]
  ------------------
  151|      1|    case chCloseCurly:
  ------------------
  |  Branch (151:5): [True: 0, False: 1]
  ------------------
  152|      1|    case chOpenParen:
  ------------------
  |  Branch (152:5): [True: 0, False: 1]
  ------------------
  153|      1|    case chCloseParen:
  ------------------
  |  Branch (153:5): [True: 0, False: 1]
  ------------------
  154|      1|    case chOpenSquare:
  ------------------
  |  Branch (154:5): [True: 0, False: 1]
  ------------------
  155|      1|    case chCloseSquare:
  ------------------
  |  Branch (155:5): [True: 0, False: 1]
  ------------------
  156|      1|        break;
  157|      0|    default:
  ------------------
  |  Branch (157:5): [True: 0, False: 1]
  ------------------
  158|      0|        {
  159|      0|        XMLCh chString[] = {chBackSlash, (XMLCh)ch, chNull};
  160|      0|        ThrowXMLwithMemMgr1(ParseException,XMLExcepts::Parser_Process2, chString, getMemoryManager());
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  161|      1|        }
  162|      1|    }
  163|       |
  164|      1|    return ch;
  165|      1|}

_ZN11xercesc_3_212RangeFactoryC2Ev:
   35|      4|{
   36|       |
   37|      4|}

_ZN11xercesc_3_210RangeTokenC2ENS_5Token7tokTypeEPNS_13MemoryManagerE:
   69|    295|{
   70|       |
   71|    295|}
_ZN11xercesc_3_210RangeToken14setRangeValuesEPij:
  313|      4|{
  314|      4|    if (fRanges) {
  ------------------
  |  Branch (314:9): [True: 0, False: 4]
  ------------------
  315|       |
  316|      0|        if (fMap) {
  ------------------
  |  Branch (316:13): [True: 0, False: 0]
  ------------------
  317|      0|            fMemoryManager->deallocate(fMap);//delete [] fMap;
  318|      0|            fMap = 0;
  319|      0|        }
  320|       |
  321|      0|        fElemCount = 0;
  322|      0|        fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  323|      0|        fRanges = 0;
  324|      0|    }
  325|       |
  326|      4|    fElemCount = fMaxCount = count;
  327|      4|    fRanges = rangeValues;
  328|      4|}
_ZN11xercesc_3_210RangeToken8addRangeEii:
  333|   151k|void RangeToken::addRange(const XMLInt32 start, const XMLInt32 end) {
  334|       |
  335|   151k|    XMLInt32 val1, val2;
  336|       |
  337|   151k|    fCaseIToken = 0;
  338|       |
  339|   151k|    if (start <= end) {
  ------------------
  |  Branch (339:9): [True: 151k, False: 1]
  ------------------
  340|       |
  341|   151k|        val1 = start;
  342|   151k|        val2 = end;
  343|   151k|    }
  344|      1|    else {
  345|       |
  346|      1|        val1 = end;
  347|      1|        val2 = start;
  348|      1|    }
  349|       |
  350|   151k|    if (fRanges == 0) {
  ------------------
  |  Branch (350:9): [True: 287, False: 151k]
  ------------------
  351|       |
  352|    287|        fRanges = (XMLInt32*) fMemoryManager->allocate
  353|    287|        (
  354|    287|            fMaxCount * sizeof(XMLInt32)
  355|    287|        );//new XMLInt32[fMaxCount];
  356|    287|        fRanges[0] = val1;
  357|    287|        fRanges[1] = val2;
  358|    287|        fElemCount = 2;
  359|    287|        fSorted = true;
  360|    287|    }
  361|   151k|    else {
  362|       |
  363|   151k|        if (fRanges[fElemCount-1] + 1 == val1) {
  ------------------
  |  Branch (363:13): [True: 142k, False: 8.09k]
  ------------------
  364|       |
  365|   142k|            fRanges[fElemCount-1] = val2;
  366|   142k|            return;
  367|   142k|        }
  368|       |
  369|  8.09k|        if (fElemCount + 2 >= fMaxCount) {
  ------------------
  |  Branch (369:13): [True: 803, False: 7.29k]
  ------------------
  370|    803|            expand(2);
  371|    803|        }
  372|       |
  373|  8.09k|        if(fSorted && fRanges[fElemCount-1] >= val1)
  ------------------
  |  Branch (373:12): [True: 8.09k, False: 0]
  |  Branch (373:23): [True: 7, False: 8.08k]
  ------------------
  374|      7|        {
  375|      9|            for (int i = 0; i < (int)fElemCount; i +=2)
  ------------------
  |  Branch (375:29): [True: 9, False: 0]
  ------------------
  376|      9|            {
  377|       |                // check if this range is already part of this one
  378|      9|                if (fRanges[i] <= val1 && fRanges[i+1] >= val2)
  ------------------
  |  Branch (378:21): [True: 2, False: 7]
  |  Branch (378:43): [True: 0, False: 2]
  ------------------
  379|      0|                    break;
  380|       |                // or if the new one extends the old one
  381|      9|                else if(fRanges[i]==val1 && fRanges[i+1] < val2)
  ------------------
  |  Branch (381:25): [True: 0, False: 9]
  |  Branch (381:45): [True: 0, False: 0]
  ------------------
  382|      0|                {
  383|      0|                    fRanges[i+1]=val2;
  384|      0|                    break;
  385|      0|                }
  386|      9|                else if (fRanges[i] > val1 ||
  ------------------
  |  Branch (386:26): [True: 7, False: 2]
  ------------------
  387|      9|                          (fRanges[i]==val1 && fRanges[i+1] > val2))
  ------------------
  |  Branch (387:28): [True: 0, False: 2]
  |  Branch (387:48): [True: 0, False: 0]
  ------------------
  388|      7|                {
  389|  2.04k|                    for(int j=fElemCount-1;j>=i;j--)
  ------------------
  |  Branch (389:44): [True: 2.04k, False: 7]
  ------------------
  390|  2.04k|                        fRanges[j+2]=fRanges[j];
  391|      7|                    fRanges[i]   = val1;
  392|      7|                    fRanges[i+1] = val2;
  393|      7|                    fElemCount  += 2;
  394|      7|                    break;
  395|      7|                }
  396|      9|            }
  397|      7|        }
  398|  8.08k|        else
  399|  8.08k|        {
  400|  8.08k|            if (fRanges[fElemCount-1] >= val1)
  ------------------
  |  Branch (400:17): [True: 0, False: 8.08k]
  ------------------
  401|      0|                fSorted = false;
  402|       |
  403|  8.08k|            fRanges[fElemCount++] = val1;
  404|  8.08k|            fRanges[fElemCount++] = val2;
  405|       |
  406|  8.08k|            if (!fSorted) {
  ------------------
  |  Branch (406:17): [True: 0, False: 8.08k]
  ------------------
  407|      0|                sortRanges();
  408|      0|            }
  409|  8.08k|        }
  410|  8.09k|    }
  411|   151k|}
_ZN11xercesc_3_210RangeToken10sortRangesEv:
  413|    168|void RangeToken::sortRanges() {
  414|       |
  415|    168|    if (fSorted || fRanges == 0)
  ------------------
  |  Branch (415:9): [True: 160, False: 8]
  |  Branch (415:20): [True: 4, False: 4]
  ------------------
  416|    164|        return;
  417|       |
  418|    556|    for (int i = fElemCount - 4; i >= 0; i -= 2) {
  ------------------
  |  Branch (418:34): [True: 552, False: 4]
  ------------------
  419|       |
  420|  76.2k|        for (int j = 0; j <= i; j +=2) {
  ------------------
  |  Branch (420:25): [True: 75.7k, False: 552]
  ------------------
  421|       |
  422|  75.7k|            if (fRanges[j] > fRanges[j + 2]
  ------------------
  |  Branch (422:17): [True: 23.1k, False: 52.5k]
  ------------------
  423|  75.7k|                || (fRanges[j]==fRanges[j+2] && fRanges[j+1] > fRanges[j+3])) {
  ------------------
  |  Branch (423:21): [True: 0, False: 52.5k]
  |  Branch (423:49): [True: 0, False: 0]
  ------------------
  424|       |
  425|  23.1k|                XMLInt32 tmpVal = fRanges[j+2];
  426|  23.1k|                fRanges[j+2] = fRanges[j];
  427|  23.1k|                fRanges[j] = tmpVal;
  428|  23.1k|                tmpVal = fRanges[j+3];
  429|  23.1k|                fRanges[j+3] = fRanges[j+1];
  430|  23.1k|                fRanges[j+1] = tmpVal;
  431|  23.1k|            }
  432|  75.7k|        }
  433|    552|    }
  434|       |
  435|      4|    fSorted = true;
  436|      4|}
_ZN11xercesc_3_210RangeToken13compactRangesEv:
  438|    152|void RangeToken::compactRanges() {
  439|       |
  440|    152|    if (fCompacted || fRanges == 0 || fElemCount <= 2)
  ------------------
  |  Branch (440:9): [True: 4, False: 148]
  |  Branch (440:23): [True: 0, False: 148]
  |  Branch (440:39): [True: 98, False: 50]
  ------------------
  441|    102|        return;
  442|       |
  443|     50|    unsigned int base = 0;
  444|     50|    unsigned int target = 0;
  445|       |
  446|  4.31k|    while (target < fElemCount) {
  ------------------
  |  Branch (446:12): [True: 4.26k, False: 50]
  ------------------
  447|       |
  448|  4.26k|        if (base != target) {
  ------------------
  |  Branch (448:13): [True: 774, False: 3.49k]
  ------------------
  449|       |
  450|    774|            fRanges[base] = fRanges[target++];
  451|    774|            fRanges[base+1] = fRanges[target++];
  452|    774|        }
  453|  3.49k|        else
  454|  3.49k|            target += 2;
  455|       |
  456|  4.26k|        XMLInt32 baseEnd = fRanges[base + 1];
  457|       |
  458|  5.03k|        while (target < fElemCount) {
  ------------------
  |  Branch (458:16): [True: 4.98k, False: 50]
  ------------------
  459|       |
  460|  4.98k|            XMLInt32 startRange = fRanges[target];
  461|       |
  462|  4.98k|            if (baseEnd + 1 < startRange)
  ------------------
  |  Branch (462:17): [True: 4.21k, False: 765]
  ------------------
  463|  4.21k|                break;
  464|       |
  465|    765|            XMLInt32 endRange = fRanges[target + 1];
  466|       |
  467|    765|            if (baseEnd + 1 == startRange || baseEnd < endRange) {
  ------------------
  |  Branch (467:17): [True: 765, False: 0]
  |  Branch (467:46): [True: 0, False: 0]
  ------------------
  468|       |
  469|    765|                baseEnd = endRange;
  470|    765|                fRanges[base+1] = baseEnd;
  471|    765|                target += 2;
  472|    765|            }
  473|      0|            else if (baseEnd >= endRange) {
  ------------------
  |  Branch (473:22): [True: 0, False: 0]
  ------------------
  474|      0|                target += 2;
  475|      0|            }
  476|      0|            else {
  477|      0|                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_CompactRangesError, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  478|      0|            }
  479|    765|        } // inner while
  480|       |
  481|  4.26k|        base += 2;
  482|  4.26k|    }
  483|       |
  484|     50|    fElemCount = base;
  485|     50|    fCompacted = true;
  486|     50|}
_ZN11xercesc_3_210RangeToken11mergeRangesEPKNS_5TokenE:
  488|      8|void RangeToken::mergeRanges(const Token *const tok) {
  489|       |
  490|       |
  491|      8|    if (tok->getTokenType() != this->getTokenType())
  ------------------
  |  Branch (491:9): [True: 0, False: 8]
  ------------------
  492|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Regex_MergeRangesTypeMismatch, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  493|       |
  494|      8|    RangeToken* rangeTok = (RangeToken *) tok;
  495|       |
  496|      8|    if (rangeTok->fRanges == 0)
  ------------------
  |  Branch (496:9): [True: 0, False: 8]
  ------------------
  497|      0|        return;
  498|       |
  499|      8|    fCaseIToken = 0;
  500|      8|    sortRanges();
  501|      8|    rangeTok->sortRanges();
  502|       |
  503|      8|    if (fRanges == 0) {
  ------------------
  |  Branch (503:9): [True: 4, False: 4]
  ------------------
  504|       |
  505|      4|        fMaxCount = rangeTok->fMaxCount;
  506|      4|        fRanges = (XMLInt32*) fMemoryManager->allocate
  507|      4|        (
  508|      4|            fMaxCount * sizeof(XMLInt32)
  509|      4|        );//new XMLInt32[fMaxCount];
  510|  4.81k|        for (unsigned int index = 0; index < rangeTok->fElemCount; index++) {
  ------------------
  |  Branch (510:38): [True: 4.81k, False: 4]
  ------------------
  511|  4.81k|            fRanges[index] = rangeTok->fRanges[index];
  512|  4.81k|        }
  513|       |
  514|      4|        fElemCount = rangeTok->fElemCount;
  515|      4|        fSorted = true;
  516|      4|        return;
  517|      4|    }
  518|       |
  519|      4|    unsigned int newMaxCount = (fElemCount + rangeTok->fElemCount >= fMaxCount)
  ------------------
  |  Branch (519:32): [True: 3, False: 1]
  ------------------
  520|      4|                                 ? fMaxCount + rangeTok->fMaxCount : fMaxCount;
  521|      4|    XMLInt32* result = (XMLInt32*) fMemoryManager->allocate
  522|      4|    (
  523|      4|        newMaxCount * sizeof(XMLInt32)
  524|      4|    );//new XMLInt32[newMaxCount];
  525|       |
  526|  2.80k|    for (unsigned int i=0, j=0, k=0; i < fElemCount || j < rangeTok->fElemCount;) {
  ------------------
  |  Branch (526:38): [True: 2.79k, False: 12]
  |  Branch (526:56): [True: 8, False: 4]
  ------------------
  527|       |
  528|  2.80k|        if (i >= fElemCount) {
  ------------------
  |  Branch (528:13): [True: 8, False: 2.79k]
  ------------------
  529|       |
  530|     24|            for (int count = 0; count < 2; count++) {
  ------------------
  |  Branch (530:33): [True: 16, False: 8]
  ------------------
  531|     16|                result[k++] = rangeTok->fRanges[j++];
  532|     16|            }
  533|      8|        }
  534|  2.79k|        else if (j >= rangeTok->fElemCount) {
  ------------------
  |  Branch (534:18): [True: 12, False: 2.78k]
  ------------------
  535|       |
  536|     36|            for (int count = 0; count < 2; count++) {
  ------------------
  |  Branch (536:33): [True: 24, False: 12]
  ------------------
  537|     24|                result[k++] = fRanges[i++];
  538|     24|            }
  539|     12|        }
  540|  2.78k|        else if (rangeTok->fRanges[j] < fRanges[i]
  ------------------
  |  Branch (540:18): [True: 618, False: 2.16k]
  ------------------
  541|  2.78k|                 || (rangeTok->fRanges[j] == fRanges[i]
  ------------------
  |  Branch (541:22): [True: 0, False: 2.16k]
  ------------------
  542|  2.16k|                     && rangeTok->fRanges[j+1] < fRanges[i+1])) {
  ------------------
  |  Branch (542:25): [True: 0, False: 0]
  ------------------
  543|       |
  544|  1.85k|            for (int count = 0; count < 2; count++) {
  ------------------
  |  Branch (544:33): [True: 1.23k, False: 618]
  ------------------
  545|  1.23k|                result[k++] = rangeTok->fRanges[j++];
  546|  1.23k|            }
  547|    618|        }
  548|  2.16k|        else {
  549|       |
  550|  6.49k|            for (int count = 0; count < 2; count++) {
  ------------------
  |  Branch (550:33): [True: 4.33k, False: 2.16k]
  ------------------
  551|       |
  552|  4.33k|                result[k++] = fRanges[i++];
  553|  4.33k|            }
  554|  2.16k|        }
  555|  2.80k|    }
  556|       |
  557|      4|    fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  558|      4|    fElemCount += rangeTok->fElemCount;
  559|      4|    fRanges = result;
  560|      4|    fMaxCount = newMaxCount;
  561|      4|}
_ZN11xercesc_3_210RangeToken16complementRangesEPS0_PNS_12TokenFactoryEPNS_13MemoryManagerE:
  743|    143|                                    MemoryManager* const manager) {
  744|       |
  745|    143|    if (tok->getTokenType() != T_RANGE && tok->getTokenType() != T_NRANGE)
  ------------------
  |  Branch (745:9): [True: 0, False: 143]
  |  Branch (745:43): [True: 0, False: 0]
  ------------------
  746|      0|        ThrowXMLwithMemMgr(IllegalArgumentException, XMLExcepts::Regex_ComplementRangesInvalidArg, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  747|       |
  748|    143|    tok->sortRanges();
  749|    143|    tok->compactRanges();
  750|       |
  751|    143|    XMLInt32 lastElem = tok->fRanges[tok->fElemCount - 1];
  752|    143|    RangeToken* rangeTok = tokFactory->createRange();
  753|       |
  754|    143|    if (tok->fRanges[0] > 0) {
  ------------------
  |  Branch (754:9): [True: 138, False: 5]
  ------------------
  755|    138|        rangeTok->addRange(0, tok->fRanges[0] - 1);
  756|    138|    }
  757|       |
  758|  4.69k|    for (unsigned int i= 1; i< tok->fElemCount - 2; i += 2) {
  ------------------
  |  Branch (758:29): [True: 4.55k, False: 143]
  ------------------
  759|  4.55k|        rangeTok->addRange(tok->fRanges[i] + 1, tok->fRanges[i+1] - 1);
  760|  4.55k|    }
  761|       |
  762|    143|    if (lastElem != UTF16_MAX) {
  ------------------
  |  Branch (762:9): [True: 141, False: 2]
  ------------------
  763|    141|        rangeTok->addRange(lastElem + 1, UTF16_MAX);
  764|    141|    }
  765|       |
  766|    143|    rangeTok->fCompacted = true;
  767|       |
  768|    143|    return rangeTok;
  769|    143|}
_ZN11xercesc_3_210RangeToken5matchEi:
  775|    132|bool RangeToken::match(const XMLInt32 ch) {
  776|       |
  777|    132|    createMap();
  778|       |
  779|    132|    bool ret;
  780|       |
  781|    132|    if (getTokenType() == T_RANGE) {
  ------------------
  |  Branch (781:9): [True: 132, False: 0]
  ------------------
  782|       |
  783|    132|        if (ch < MAPSIZE)
  ------------------
  |  Branch (783:13): [True: 132, False: 0]
  ------------------
  784|    132|            return ((fMap[ch/32] & (1<<(ch&0x1f))) != 0);
  785|       |
  786|      0|        ret = false;
  787|       |
  788|      0|        for (unsigned int i= fNonMapIndex; i< fElemCount; i +=2) {
  ------------------
  |  Branch (788:44): [True: 0, False: 0]
  ------------------
  789|       |
  790|      0|            if (fRanges[i] <= ch && ch <= fRanges[i+1])
  ------------------
  |  Branch (790:17): [True: 0, False: 0]
  |  Branch (790:37): [True: 0, False: 0]
  ------------------
  791|      0|                return true;
  792|      0|        }
  793|      0|    }
  794|      0|    else {
  795|       |
  796|      0|        if (ch < MAPSIZE)
  ------------------
  |  Branch (796:13): [True: 0, False: 0]
  ------------------
  797|      0|            return ((fMap[ch/32] & (1<<(ch&0x1f))) == 0);
  798|       |
  799|      0|        ret = true;
  800|       |
  801|      0|        for (unsigned int i= fNonMapIndex; i< fElemCount; i += 2) {
  ------------------
  |  Branch (801:44): [True: 0, False: 0]
  ------------------
  802|       |
  803|      0|            if (fRanges[i] <= ch && ch <= fRanges[i+1])
  ------------------
  |  Branch (803:17): [True: 0, False: 0]
  |  Branch (803:37): [True: 0, False: 0]
  ------------------
  804|      0|                return false;
  805|      0|        }
  806|      0|    }
  807|       |
  808|      0|    return ret;
  809|    132|}
_ZN11xercesc_3_210RangeToken6expandEj:
  814|    803|void RangeToken::expand(const unsigned int length) {
  815|       |
  816|    803|    unsigned int newMax = fElemCount + length;
  817|       |
  818|       |    // Avoid too many reallocations by expanding by a percentage
  819|    803|    unsigned int minNewMax = (unsigned int)((double)fElemCount * 1.25);
  820|    803|    if (newMax < minNewMax)
  ------------------
  |  Branch (820:9): [True: 803, False: 0]
  ------------------
  821|    803|        newMax = minNewMax;
  822|       |
  823|    803|    XMLInt32* newList = (XMLInt32*) fMemoryManager->allocate
  824|    803|    (
  825|    803|        newMax * sizeof(XMLInt32)
  826|    803|    );//new XMLInt32[newMax];
  827|  74.5k|    for (unsigned int index = 0; index < fElemCount; index++)
  ------------------
  |  Branch (827:34): [True: 73.7k, False: 803]
  ------------------
  828|  73.7k|        newList[index] = fRanges[index];
  829|       |
  830|    803|    fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  831|    803|    fRanges = newList;
  832|    803|    fMaxCount = newMax;
  833|    803|}
_ZN11xercesc_3_210RangeToken11doCreateMapEv:
  835|    291|void RangeToken::doCreateMap() {
  836|       |
  837|    291|    assert(!fMap);
  838|       |
  839|      0|    int asize = MAPSIZE/32;
  840|    291|    fMap = (int*) fMemoryManager->allocate(asize * sizeof(int));//new int[asize];
  841|    291|    fNonMapIndex = fElemCount;
  842|       |
  843|  2.61k|    for (int i = 0; i < asize; i++) {
  ------------------
  |  Branch (843:21): [True: 2.32k, False: 291]
  ------------------
  844|  2.32k|        fMap[i] = 0;
  845|  2.32k|    }
  846|       |
  847|    644|    for (unsigned int j= 0; j < fElemCount; j += 2) {
  ------------------
  |  Branch (847:29): [True: 632, False: 12]
  ------------------
  848|       |
  849|    632|        XMLInt32 begin = fRanges[j];
  850|    632|        XMLInt32 end = fRanges[j+1];
  851|       |
  852|    632|        if (begin < MAPSIZE) {
  ------------------
  |  Branch (852:13): [True: 492, False: 140]
  ------------------
  853|       |
  854|  37.6k|            for (int k = begin; k <= end && k < MAPSIZE; k++) {
  ------------------
  |  Branch (854:33): [True: 37.2k, False: 353]
  |  Branch (854:45): [True: 37.1k, False: 139]
  ------------------
  855|  37.1k|                fMap[k/32] |= 1<<(k&0x1F);
  856|  37.1k|            }
  857|    492|        }
  858|    140|        else {
  859|       |
  860|    140|            fNonMapIndex = j;
  861|    140|            break;
  862|    140|        }
  863|       |
  864|    492|        if (end >= MAPSIZE) {
  ------------------
  |  Branch (864:13): [True: 139, False: 353]
  ------------------
  865|       |
  866|    139|            fNonMapIndex = j;
  867|    139|            break;
  868|    139|        }
  869|    492|    }
  870|    291|}

_ZN11xercesc_3_210RangeToken23setCaseInsensitiveTokenEPS0_:
  122|     37|{
  123|     37|    fCaseIToken = tok;
  124|     37|}
_ZN11xercesc_3_210RangeToken9createMapEv:
  127|    421|{
  128|    421|    if (!fMap)
  ------------------
  |  Branch (128:9): [True: 291, False: 130]
  ------------------
  129|    291|    {
  130|    291|        doCreateMap();
  131|    291|    }
  132|    421|}

_ZN11xercesc_3_214XMLInitializer23initializeRangeTokenMapEv:
   44|      1|{
   45|      1|    RangeTokenMap::fInstance = new RangeTokenMap(
   46|      1|      XMLPlatformUtils::fgMemoryManager);
   47|       |
   48|      1|    if (RangeTokenMap::fInstance)
  ------------------
  |  Branch (48:9): [True: 1, False: 0]
  ------------------
   49|      1|      RangeTokenMap::fInstance->buildTokenRanges();
   50|      1|}
_ZN11xercesc_3_217RangeTokenElemMapC2Ej:
   66|    146|{
   67|       |
   68|    146|}
_ZN11xercesc_3_213RangeTokenMapC2EPNS_13MemoryManagerE:
   87|      1|{
   88|      1|    CleanupType cleanup(this, &RangeTokenMap::cleanUp);
   89|       |
   90|      1|    try {
   91|      1|        fTokenRegistry = new (manager) RefHashTableOf<RangeTokenElemMap>(109, manager);
   92|      1|        fRangeMap = new (manager) RefHashTableOf<RangeFactory>(29, manager);
   93|      1|        fCategories = new (manager) XMLStringPool(109, manager);
   94|      1|        fTokenFactory = new (manager) TokenFactory(manager);
   95|      1|        initializeRegistry();
   96|      1|    }
   97|      1|    catch(const OutOfMemoryException&)
   98|      1|    {
   99|      0|        cleanup.release();
  100|       |
  101|      0|        throw;
  102|      0|    }
  103|       |
  104|      1|    cleanup.release();
  105|      1|}
_ZN11xercesc_3_213RangeTokenMap8getRangeEPKDsb:
  116|      2|                                    const bool complement) {
  117|       |
  118|      2|    if (!fTokenRegistry->containsKey(keyword))
  ------------------
  |  Branch (118:9): [True: 0, False: 2]
  ------------------
  119|      0|        return 0;
  120|       |
  121|      2|    RangeTokenElemMap* elemMap = fTokenRegistry->get(keyword);
  122|      2|    RangeToken* rangeTok = elemMap->getRangeToken(complement);
  123|       |
  124|      2|    if (!rangeTok)
  ------------------
  |  Branch (124:9): [True: 0, False: 2]
  ------------------
  125|      0|    {
  126|      0|        XMLMutexLock lockInit(&fMutex);
  127|       |
  128|       |        // make sure that it was not created while we were locked
  129|      0|        rangeTok = elemMap->getRangeToken(complement);
  130|       |
  131|      0|        if (!rangeTok)
  ------------------
  |  Branch (131:13): [True: 0, False: 0]
  ------------------
  132|      0|        {
  133|      0|            unsigned int categId = elemMap->getCategoryId();
  134|      0|            const XMLCh* categName = fCategories->getValueForId(categId);
  135|      0|            RangeFactory* rangeFactory = fRangeMap->get(categName);
  136|       |
  137|      0|            if (rangeFactory)
  ------------------
  |  Branch (137:17): [True: 0, False: 0]
  ------------------
  138|      0|            {
  139|      0|                rangeFactory->buildRanges(this);
  140|      0|                rangeTok = elemMap->getRangeToken(complement);
  141|       |
  142|       |                // see if we are complementing an existing range
  143|      0|                if (!rangeTok && complement)
  ------------------
  |  Branch (143:21): [True: 0, False: 0]
  |  Branch (143:34): [True: 0, False: 0]
  ------------------
  144|      0|                {
  145|      0|                    rangeTok = elemMap->getRangeToken();
  146|      0|                    if (rangeTok)
  ------------------
  |  Branch (146:25): [True: 0, False: 0]
  ------------------
  147|      0|                    {
  148|      0|                        rangeTok = RangeToken::complementRanges(rangeTok, fTokenFactory, fTokenRegistry->getMemoryManager());
  149|      0|                        elemMap->setRangeToken(rangeTok , complement);
  150|      0|                    }
  151|      0|                }
  152|      0|            }
  153|      0|        }
  154|      0|    }
  155|       |
  156|      2|    return rangeTok;
  157|      2|}
_ZN11xercesc_3_213RangeTokenMap13addKeywordMapEPKDsS2_:
  175|    146|                                 const XMLCh* const categoryName) {
  176|       |
  177|    146|    unsigned int categId = fCategories->getId(categoryName);
  178|       |
  179|    146|    if (categId == 0) {
  ------------------
  |  Branch (179:9): [True: 0, False: 146]
  ------------------
  180|      0|        ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Regex_InvalidCategoryName, categoryName, fTokenRegistry->getMemoryManager());
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  181|      0|    }
  182|       |
  183|    146|    if (fTokenRegistry->containsKey(keyword)) {
  ------------------
  |  Branch (183:9): [True: 0, False: 146]
  ------------------
  184|       |
  185|      0|        RangeTokenElemMap* elemMap = fTokenRegistry->get(keyword);
  186|       |
  187|      0|        if (elemMap->getCategoryId() != categId)
  ------------------
  |  Branch (187:13): [True: 0, False: 0]
  ------------------
  188|      0|            elemMap->setCategoryId(categId);
  189|       |
  190|      0|        return;
  191|      0|    }
  192|       |
  193|    146|    fTokenRegistry->put((void*) keyword, new RangeTokenElemMap(categId));
  194|    146|}
_ZN11xercesc_3_213RangeTokenMap13setRangeTokenEPKDsPNS_10RangeTokenEb:
  200|    288|                                  RangeToken* const tok,const bool complement) {
  201|       |
  202|    288|    if (fTokenRegistry->containsKey(keyword)) {
  ------------------
  |  Branch (202:9): [True: 288, False: 0]
  ------------------
  203|    288|        fTokenRegistry->get(keyword)->setRangeToken(tok, complement);
  204|    288|    }
  205|      0|    else {
  206|      0|        ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Regex_KeywordNotFound, keyword, fTokenRegistry->getMemoryManager());
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  207|      0|    }
  208|    288|}
_ZN11xercesc_3_213RangeTokenMap18initializeRegistryEv:
  214|      1|void RangeTokenMap::initializeRegistry() {
  215|       |
  216|       |    // Add categories
  217|      1|    fCategories->addOrFind(fgXMLCategory);
  218|      1|    fCategories->addOrFind(fgASCIICategory);
  219|      1|    fCategories->addOrFind(fgUnicodeCategory);
  220|      1|    fCategories->addOrFind(fgBlockCategory);
  221|       |
  222|       |    // Add xml range factory
  223|      1|    RangeFactory* rangeFact = new XMLRangeFactory();
  224|      1|    fRangeMap->put((void*)fgXMLCategory, rangeFact);
  225|      1|    rangeFact->initializeKeywordMap(this);
  226|       |
  227|       |    // Add ascii range factory
  228|      1|    rangeFact = new ASCIIRangeFactory();
  229|      1|    fRangeMap->put((void*)fgASCIICategory, rangeFact);
  230|      1|    rangeFact->initializeKeywordMap(this);
  231|       |
  232|       |    // Add unicode range factory
  233|      1|    rangeFact = new UnicodeRangeFactory();
  234|      1|    fRangeMap->put((void*)fgUnicodeCategory, rangeFact);
  235|      1|    rangeFact->initializeKeywordMap(this);
  236|       |
  237|       |    // Add block range factory
  238|      1|    rangeFact = new BlockRangeFactory();
  239|      1|    fRangeMap->put((void*)fgBlockCategory, rangeFact);
  240|      1|    rangeFact->initializeKeywordMap(this);
  241|      1|}
_ZN11xercesc_3_213RangeTokenMap16buildTokenRangesEv:
  244|      1|{
  245|       |    // Build ranges */
  246|      1|    RangeFactory* rangeFactory = fRangeMap->get(fgXMLCategory);
  247|      1|    rangeFactory->buildRanges(this);
  248|       |
  249|      1|    rangeFactory = fRangeMap->get(fgASCIICategory);
  250|      1|    rangeFactory->buildRanges(this);
  251|       |
  252|      1|    rangeFactory = fRangeMap->get(fgUnicodeCategory);
  253|      1|    rangeFactory->buildRanges(this);
  254|       |
  255|      1|    rangeFactory = fRangeMap->get(fgBlockCategory);
  256|      1|    rangeFactory->buildRanges(this);
  257|      1|}
_ZN11xercesc_3_213RangeTokenMap8instanceEv:
  263|      2|{
  264|      2|    return fInstance;
  265|      2|}

_ZNK11xercesc_3_217RangeTokenElemMap13getRangeTokenEb:
  181|      2|inline RangeToken* RangeTokenElemMap::getRangeToken(const bool complement) const {
  182|       |
  183|      2|    return complement ? fNRange : fRange;
  ------------------
  |  Branch (183:12): [True: 0, False: 2]
  ------------------
  184|      2|}
_ZN11xercesc_3_217RangeTokenElemMap13setRangeTokenEPNS_10RangeTokenEb:
  195|    288|                                      const bool complement) {
  196|       |
  197|    288|    if (complement)
  ------------------
  |  Branch (197:9): [True: 142, False: 146]
  ------------------
  198|    142|        fNRange = tok;
  199|    146|    else
  200|    146|        fRange = tok;
  201|    288|}
_ZNK11xercesc_3_213RangeTokenMap15getTokenFactoryEv:
  221|      4|inline TokenFactory* RangeTokenMap::getTokenFactory() const {
  222|       |
  223|      4|    return fTokenFactory;
  224|      4|}

_ZN11xercesc_3_217RegularExpression7ContextC2EPNS_13MemoryManagerE:
  119|     32|{
  120|     32|}
_ZN11xercesc_3_217RegularExpression7ContextC2EPS1_:
  134|     27|{
  135|     27|    if(src->fOffsets)
  ------------------
  |  Branch (135:8): [True: 0, False: 27]
  ------------------
  136|      0|    {
  137|      0|        fOffsets = (int*) fMemoryManager->allocate(fSize* sizeof(int));
  138|      0|        for (int i = 0; i< fSize; i++)
  ------------------
  |  Branch (138:25): [True: 0, False: 0]
  ------------------
  139|      0|            fOffsets[i] = src->fOffsets[i];
  140|      0|    }
  141|     27|    if(src->fMatch)
  ------------------
  |  Branch (141:8): [True: 0, False: 27]
  ------------------
  142|      0|    {
  143|      0|        fMatch=new (fMemoryManager) Match(*src->fMatch);
  144|      0|        fAdoptMatch=true;
  145|      0|    }
  146|     27|}
_ZN11xercesc_3_217RegularExpression7ContextaSERKS1_:
  149|     32|{
  150|     32|    if (this != &other)
  ------------------
  |  Branch (150:9): [True: 32, False: 0]
  ------------------
  151|     32|    {
  152|     32|        fStart=other.fStart;
  153|     32|        fLimit=other.fLimit;
  154|     32|        fLength=other.fLength;
  155|     32|        fStringMaxLen=other.fStringMaxLen;
  156|     32|        fString=other.fString;
  157|     32|        fOptions=other.fOptions;
  158|       |
  159|       |        // if offset and match are already allocated with the right size, reuse them 
  160|       |        // (fMatch can be provided by the user to get the data back)
  161|     32|        if(fMatch && other.fMatch && fMatch->getNoGroups()==other.fMatch->getNoGroups())
  ------------------
  |  Branch (161:12): [True: 0, False: 32]
  |  Branch (161:22): [True: 0, False: 0]
  |  Branch (161:38): [True: 0, False: 0]
  ------------------
  162|      0|            *fMatch=*other.fMatch;
  163|     32|        else
  164|     32|        {
  165|     32|            if (fAdoptMatch)
  ------------------
  |  Branch (165:17): [True: 0, False: 32]
  ------------------
  166|      0|                delete fMatch;
  167|     32|            fMatch=0;
  168|     32|            if(other.fMatch)
  ------------------
  |  Branch (168:16): [True: 0, False: 32]
  ------------------
  169|      0|            {
  170|      0|                fMatch=new (other.fMemoryManager) Match(*other.fMatch);
  171|      0|                fAdoptMatch=true;
  172|      0|            }
  173|     32|        }
  174|       |
  175|     32|        if (fOffsets && other.fOffsets && fSize==other.fSize)
  ------------------
  |  Branch (175:13): [True: 0, False: 32]
  |  Branch (175:25): [True: 0, False: 0]
  |  Branch (175:43): [True: 0, False: 0]
  ------------------
  176|      0|        {
  177|      0|            for (int i = 0; i< fSize; i++)
  ------------------
  |  Branch (177:29): [True: 0, False: 0]
  ------------------
  178|      0|                fOffsets[i] = other.fOffsets[i];
  179|      0|        }
  180|     32|        else
  181|     32|        {
  182|     32|            if(fOffsets)
  ------------------
  |  Branch (182:16): [True: 0, False: 32]
  ------------------
  183|      0|                fMemoryManager->deallocate(fOffsets);//delete [] fOffsets;
  184|     32|            fOffsets=0;
  185|     32|            fSize=other.fSize;
  186|     32|            if(other.fOffsets)
  ------------------
  |  Branch (186:16): [True: 0, False: 32]
  ------------------
  187|      0|            {
  188|      0|                fOffsets = (int*) other.fMemoryManager->allocate(fSize* sizeof(int));
  189|      0|                for (int i = 0; i< fSize; i++)
  ------------------
  |  Branch (189:33): [True: 0, False: 0]
  ------------------
  190|      0|                    fOffsets[i] = other.fOffsets[i];
  191|      0|            }
  192|     32|        }
  193|       |
  194|     32|        fMemoryManager=other.fMemoryManager;
  195|     32|    }
  196|       |
  197|     32|    return *this;
  198|     32|}
_ZN11xercesc_3_217RegularExpression7ContextD2Ev:
  201|     59|{
  202|     59|    if (fOffsets)
  ------------------
  |  Branch (202:9): [True: 0, False: 59]
  ------------------
  203|      0|        fMemoryManager->deallocate(fOffsets);//delete [] fOffsets;
  204|       |
  205|     59|    if (fAdoptMatch)
  ------------------
  |  Branch (205:9): [True: 0, False: 59]
  ------------------
  206|      0|        delete fMatch;
  207|     59|}
_ZN11xercesc_3_217RegularExpression7Context5resetEPKDsmmmij:
  218|     16|{
  219|     16|    fString = string;
  220|     16|    fStringMaxLen = stringLen;
  221|     16|    fStart = start;
  222|     16|    fLimit = limit;
  223|     16|    fLength = fLimit - fStart;
  224|     16|    if (fAdoptMatch)
  ------------------
  |  Branch (224:9): [True: 0, False: 16]
  ------------------
  225|      0|        delete fMatch;
  226|     16|    fMatch = 0;
  227|       |
  228|     16|    if (fSize != noClosures) {
  ------------------
  |  Branch (228:9): [True: 0, False: 16]
  ------------------
  229|      0|        if (fOffsets)
  ------------------
  |  Branch (229:13): [True: 0, False: 0]
  ------------------
  230|      0|            fMemoryManager->deallocate(fOffsets);//delete [] fOffsets;
  231|      0|        fOffsets = (int*) fMemoryManager->allocate(noClosures * sizeof(int));//new int[noClosures];
  232|      0|    }
  233|       |
  234|     16|    fSize = noClosures;
  235|     16|    fOptions = options;
  236|       |
  237|     16|    for (int i = 0; i< fSize; i++)
  ------------------
  |  Branch (237:21): [True: 0, False: 16]
  ------------------
  238|      0|        fOffsets[i] = -1;
  239|     16|}
_ZN11xercesc_3_217RegularExpression7Context6nextChERiRm:
  242|    132|{
  243|    132|    ch = fString[offset];
  244|       |
  245|    132|    if (RegxUtil::isHighSurrogate(ch)) {
  ------------------
  |  Branch (245:9): [True: 0, False: 132]
  ------------------
  246|      0|        if ((offset + 1 < fLimit) && RegxUtil::isLowSurrogate(fString[offset+1])) {
  ------------------
  |  Branch (246:13): [True: 0, False: 0]
  |  Branch (246:38): [True: 0, False: 0]
  ------------------
  247|      0|            ch = RegxUtil::composeFromSurrogate(ch, fString[++offset]);
  248|      0|        }
  249|      0|        else return false;
  250|      0|    }
  251|    132|    else if (RegxUtil::isLowSurrogate(ch)) {
  ------------------
  |  Branch (251:14): [True: 0, False: 132]
  ------------------
  252|      0|        return false;
  253|      0|    }
  254|       |
  255|    132|    return true;
  256|    132|}
_ZN11xercesc_3_217RegularExpressionC2EPKDsS2_PNS_13MemoryManagerE:
  392|      4|{
  393|      4|    CleanupType cleanup(this, &RegularExpression::cleanUp);
  394|       |
  395|      4|    try {
  396|       |
  397|      4|        setPattern(pattern, options);
  398|      4|    }
  399|      4|    catch(const OutOfMemoryException&)
  400|      4|    {
  401|      0|        cleanup.release();
  402|       |
  403|      0|        throw;
  404|      0|    }
  405|       |
  406|      4|    cleanup.release();
  407|      4|}
_ZN11xercesc_3_217RegularExpression14getRegexParserEiPNS_13MemoryManagerE:
  419|      4|{
  420|       |    // the following construct causes an error in an Intel 7.1 32 bit compiler for
  421|       |    // red hat linux 7.2
  422|       |    // (when an exception is thrown the wrong object is deleted)
  423|       |    //RegxParser* regxParser = isSet(fOptions, XMLSCHEMA_MODE)
  424|       |    //    ? new (fMemoryManager) ParserForXMLSchema(fMemoryManager)
  425|       |    //    : new (fMemoryManager) RegxParser(fMemoryManager);
  426|      4|    if (isSet(options, XMLSCHEMA_MODE))
  ------------------
  |  Branch (426:9): [True: 4, False: 0]
  ------------------
  427|      4|        return new (manager) ParserForXMLSchema(manager);
  428|       |
  429|      0|    return new (manager) RegxParser(manager);
  430|      4|}
_ZN11xercesc_3_217RegularExpression10setPatternEPKDsS2_:
  434|      4|{
  435|       |
  436|      4|    fTokenFactory = new (fMemoryManager) TokenFactory(fMemoryManager);
  437|      4|    fOptions = parseOptions(options);
  438|      4|    fPattern = XMLString::replicate(pattern, fMemoryManager);
  439|       |
  440|      4|    RegxParser* regxParser=getRegexParser(fOptions, fMemoryManager);
  441|       |
  442|      4|    if (regxParser)
  ------------------
  |  Branch (442:9): [True: 4, False: 0]
  ------------------
  443|      4|        regxParser->setTokenFactory(fTokenFactory);
  444|       |
  445|      4|    Janitor<RegxParser> janRegxParser(regxParser);
  446|      4|    fTokenTree = regxParser->parse(fPattern, fOptions);
  447|      4|    fNoGroups = regxParser->getNoParen();
  448|      4|    fHasBackReferences = regxParser->hasBackReferences();
  449|       |
  450|      4|    prepare();
  451|      4|}
_ZNK11xercesc_3_217RegularExpression7matchesEPKDsPNS_13MemoryManagerE:
  499|     16|{
  500|     16|    return matches(expression, 0, XMLString::stringLen(expression), 0, manager);
  501|     16|}
_ZNK11xercesc_3_217RegularExpression7matchesEPKDsmmPNS_5MatchEPNS_13MemoryManagerE:
  520|     16|{
  521|       |
  522|     16|    Context context(manager);
  523|     16|    XMLSize_t strLength = XMLString::stringLen(expression);
  524|       |
  525|     16|    context.reset(expression, strLength, start, end, fNoClosures, fOptions);
  526|       |
  527|     16|    bool adoptMatch = false;
  528|     16|    Match* lMatch = pMatch;
  529|       |
  530|     16|    if (lMatch != 0) {
  ------------------
  |  Branch (530:9): [True: 0, False: 16]
  ------------------
  531|      0|        lMatch->setNoGroups(fNoGroups);
  532|      0|    }
  533|     16|    else if (fHasBackReferences) {
  ------------------
  |  Branch (533:14): [True: 0, False: 16]
  ------------------
  534|      0|        lMatch = new (manager) Match(manager);
  535|      0|        lMatch->setNoGroups(fNoGroups);
  536|      0|        adoptMatch = true;
  537|      0|    }
  538|       |
  539|     16|    if (context.fAdoptMatch)
  ------------------
  |  Branch (539:9): [True: 0, False: 16]
  ------------------
  540|      0|        delete context.fMatch;
  541|     16|    context.fMatch = lMatch;
  542|     16|    context.fAdoptMatch = adoptMatch;
  543|       |
  544|     16|    if (isSet(fOptions, XMLSCHEMA_MODE)) {
  ------------------
  |  Branch (544:9): [True: 16, False: 0]
  ------------------
  545|       |
  546|     16|        int matchEnd = match(&context, fOperations, context.fStart);
  547|       |
  548|     16|        if (matchEnd == (int)context.fLimit) {
  ------------------
  |  Branch (548:13): [True: 16, False: 0]
  ------------------
  549|       |
  550|     16|            if (context.fMatch != 0) {
  ------------------
  |  Branch (550:17): [True: 0, False: 16]
  ------------------
  551|       |
  552|      0|                context.fMatch->setStartPos(0, (int)context.fStart);
  553|      0|                context.fMatch->setEndPos(0, matchEnd);
  554|      0|            }
  555|     16|            return true;
  556|     16|        }
  557|       |
  558|      0|        return false;
  559|     16|    }
  560|       |
  561|       |    /*
  562|       |     * If the pattern has only fixed string, use Boyer-Moore
  563|       |     */
  564|      0|    if (fFixedStringOnly) {
  ------------------
  |  Branch (564:9): [True: 0, False: 0]
  ------------------
  565|       |
  566|      0|        int ret = fBMPattern->matches(expression, context.fStart, context.fLimit);
  567|      0|        if (ret >= 0) {
  ------------------
  |  Branch (567:13): [True: 0, False: 0]
  ------------------
  568|       |
  569|      0|            if (context.fMatch != 0) {
  ------------------
  |  Branch (569:17): [True: 0, False: 0]
  ------------------
  570|      0|                context.fMatch->setStartPos(0, ret);
  571|      0|                context.fMatch->setEndPos(0, (int)(ret + XMLString::stringLen(fPattern)));
  572|      0|            }
  573|      0|            return true;
  574|      0|        }
  575|      0|        return false;
  576|      0|    }
  577|       |
  578|       |    /*
  579|       |     * If the pattern contains a fixed string, we check with Boyer-Moore
  580|       |     * whether the text contains the fixed string or not. If not found
  581|       |     * return false
  582|       |     */
  583|      0|    if (fFixedString != 0) {
  ------------------
  |  Branch (583:9): [True: 0, False: 0]
  ------------------
  584|       |
  585|      0|        int ret = fBMPattern->matches(expression, context.fStart, context.fLimit);
  586|       |
  587|      0|        if (ret < 0) { // No match
  ------------------
  |  Branch (587:13): [True: 0, False: 0]
  ------------------
  588|      0|            return false;
  589|      0|        }
  590|      0|    }
  591|       |
  592|       |    // if the length is less than the minimum length, we cannot possibly match
  593|      0|    if(context.fLimit<fMinLength)
  ------------------
  |  Branch (593:8): [True: 0, False: 0]
  ------------------
  594|      0|        return false;
  595|       |
  596|      0|    XMLSize_t limit = context.fLimit - fMinLength;
  597|      0|    XMLSize_t matchStart;
  598|      0|    int matchEnd = -1;
  599|       |
  600|       |    /*
  601|       |     * Check whether the expression start with ".*"
  602|       |     */
  603|      0|    if (fOperations != 0 && (fOperations->getOpType() == Op::O_CLOSURE || fOperations->getOpType() == Op::O_FINITE_CLOSURE)
  ------------------
  |  Branch (603:9): [True: 0, False: 0]
  |  Branch (603:30): [True: 0, False: 0]
  |  Branch (603:75): [True: 0, False: 0]
  ------------------
  604|      0|        && fOperations->getChild()->getOpType() == Op::O_DOT) {
  ------------------
  |  Branch (604:12): [True: 0, False: 0]
  ------------------
  605|       |
  606|      0|        if (isSet(fOptions, SINGLE_LINE)) {
  ------------------
  |  Branch (606:13): [True: 0, False: 0]
  ------------------
  607|      0|            matchStart = context.fStart;
  608|      0|            matchEnd = match(&context, fOperations, matchStart);
  609|      0|        }
  610|      0|        else {
  611|      0|            bool previousIsEOL = true;
  612|       |
  613|      0|            for (matchStart=context.fStart; matchStart<=limit; matchStart++) {
  ------------------
  |  Branch (613:45): [True: 0, False: 0]
  ------------------
  614|       |
  615|      0|                XMLCh ch = expression[matchStart];
  616|      0|                if (RegxUtil::isEOLChar(ch)) {
  ------------------
  |  Branch (616:21): [True: 0, False: 0]
  ------------------
  617|      0|                    previousIsEOL = true;
  618|      0|                }
  619|      0|                else {
  620|       |
  621|      0|                    if (previousIsEOL) {
  ------------------
  |  Branch (621:25): [True: 0, False: 0]
  ------------------
  622|      0|                        if (0 <= (matchEnd = match(&context, fOperations,
  ------------------
  |  Branch (622:29): [True: 0, False: 0]
  ------------------
  623|      0|                                                   matchStart)))
  624|      0|                            break;
  625|      0|                    }
  626|       |
  627|      0|                    previousIsEOL = false;
  628|      0|                }
  629|      0|            }
  630|      0|        }
  631|      0|    }
  632|      0|    else {
  633|       |        /*
  634|       |         *    Optimization against the first char
  635|       |         */
  636|      0|        if (fFirstChar != 0) {
  ------------------
  |  Branch (636:13): [True: 0, False: 0]
  ------------------
  637|      0|            bool ignoreCase = isSet(fOptions, IGNORE_CASE);
  638|      0|            RangeToken* range = fFirstChar;
  639|       |
  640|      0|            if (ignoreCase)
  ------------------
  |  Branch (640:17): [True: 0, False: 0]
  ------------------
  641|      0|                range = fFirstChar->getCaseInsensitiveToken(fTokenFactory);
  642|       |
  643|      0|            for (matchStart=context.fStart; matchStart<=limit; matchStart++) {
  ------------------
  |  Branch (643:45): [True: 0, False: 0]
  ------------------
  644|       |
  645|      0|                XMLInt32 ch;
  646|       |
  647|      0|                if (!context.nextCh(ch, matchStart))
  ------------------
  |  Branch (647:21): [True: 0, False: 0]
  ------------------
  648|      0|                    break;
  649|       |
  650|      0|                if (!range->match(ch))
  ------------------
  |  Branch (650:21): [True: 0, False: 0]
  ------------------
  651|      0|                    continue;
  652|       |
  653|      0|                if (0 <= (matchEnd = match(&context,fOperations,matchStart)))
  ------------------
  |  Branch (653:21): [True: 0, False: 0]
  ------------------
  654|      0|                    break;
  655|      0|            }
  656|      0|        }
  657|      0|        else {
  658|       |
  659|       |            /*
  660|       |             *    Straightforward matching
  661|       |             */
  662|      0|            for (matchStart=context.fStart; matchStart<=limit; matchStart++) {
  ------------------
  |  Branch (662:45): [True: 0, False: 0]
  ------------------
  663|       |
  664|      0|                if (0 <= (matchEnd = match(&context,fOperations,matchStart)))
  ------------------
  |  Branch (664:21): [True: 0, False: 0]
  ------------------
  665|      0|                    break;
  666|      0|            }
  667|      0|        }
  668|      0|    }
  669|       |
  670|      0|    if (matchEnd >= 0) {
  ------------------
  |  Branch (670:9): [True: 0, False: 0]
  ------------------
  671|       |
  672|      0|        if (context.fMatch != 0) {
  ------------------
  |  Branch (672:13): [True: 0, False: 0]
  ------------------
  673|       |
  674|      0|            context.fMatch->setStartPos(0, (int)matchStart);
  675|      0|            context.fMatch->setEndPos(0, matchEnd);
  676|      0|        }
  677|      0|        return true;
  678|      0|    }
  679|      0|    return false;
  680|      0|}
_ZN11xercesc_3_214XMLInitializer27initializeRegularExpressionEv:
  932|      1|{
  933|      1|    RegularExpression::staticInitialize(XMLPlatformUtils::fgMemoryManager);
  934|      1|}
_ZN11xercesc_3_217RegularExpression16staticInitializeEPNS_13MemoryManagerE:
  944|      1|{
  945|      1|    fWordRange = TokenFactory::staticGetRange(fgUniIsWord, false);
  946|       |
  947|      1|    if (fWordRange == 0)
  ------------------
  |  Branch (947:9): [True: 0, False: 1]
  ------------------
  948|      0|        ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Regex_RangeTokenGetError, fgUniIsWord, memoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  949|      1|}
_ZN11xercesc_3_217RegularExpression14getOptionValueEDs:
  954|      4|int RegularExpression::getOptionValue(const XMLCh ch) {
  955|       |
  956|      4|    int ret = 0;
  957|       |
  958|      4|    switch (ch) {
  959|       |
  960|      0|        case chLatin_i:
  ------------------
  |  Branch (960:9): [True: 0, False: 4]
  ------------------
  961|      0|            ret = IGNORE_CASE;
  962|      0|            break;
  963|      0|        case chLatin_m:
  ------------------
  |  Branch (963:9): [True: 0, False: 4]
  ------------------
  964|      0|            ret = MULTIPLE_LINE;
  965|      0|            break;
  966|      0|        case chLatin_s:
  ------------------
  |  Branch (966:9): [True: 0, False: 4]
  ------------------
  967|      0|            ret = SINGLE_LINE;
  968|      0|            break;
  969|      0|        case chLatin_x:
  ------------------
  |  Branch (969:9): [True: 0, False: 4]
  ------------------
  970|      0|            ret = EXTENDED_COMMENT;
  971|      0|            break;
  972|      0|        case chLatin_F:
  ------------------
  |  Branch (972:9): [True: 0, False: 4]
  ------------------
  973|      0|            ret = PROHIBIT_FIXED_STRING_OPTIMIZATION;
  974|      0|            break;
  975|      0|        case chLatin_H:
  ------------------
  |  Branch (975:9): [True: 0, False: 4]
  ------------------
  976|      0|            ret = PROHIBIT_HEAD_CHARACTER_OPTIMIZATION;
  977|      0|            break;
  978|      4|        case chLatin_X:
  ------------------
  |  Branch (978:9): [True: 4, False: 0]
  ------------------
  979|      4|            ret = XMLSCHEMA_MODE;
  980|      4|            break;
  981|      0|        default:
  ------------------
  |  Branch (981:9): [True: 0, False: 4]
  ------------------
  982|      0|            break;
  983|      4|    }
  984|       |
  985|      4|    return ret;
  986|      4|}
_ZNK11xercesc_3_217RegularExpression5matchEPNS0_7ContextEPKNS_2OpEm:
  997|    159|{
  998|    159|    ValueStackOf<RE_RuntimeContext>* opStack=NULL;
  999|    159|    Janitor<ValueStackOf<RE_RuntimeContext> > janStack(NULL);
 1000|    159|    if(context->fLimit > 256)
  ------------------
  |  Branch (1000:8): [True: 0, False: 159]
  ------------------
 1001|      0|    {
 1002|      0|        opStack=new ValueStackOf<RE_RuntimeContext>(16, context->fMemoryManager);
 1003|      0|        janStack.reset(opStack);
 1004|      0|    }
 1005|    159|    const Op* tmpOp = operations;
 1006|    159|    bool ignoreCase = isSet(context->fOptions, IGNORE_CASE);
 1007|    159|    int doReturn;
 1008|       |
 1009|    296|    while (tmpOp != 0) {
  ------------------
  |  Branch (1009:12): [True: 180, False: 116]
  ------------------
 1010|       |        // no one wants to return -5, only -1, 0, and greater
 1011|    180|        doReturn = -5;
 1012|       |
 1013|    180|        if (offset > context->fLimit || offset < context->fStart)
  ------------------
  |  Branch (1013:13): [True: 0, False: 180]
  |  Branch (1013:41): [True: 0, False: 180]
  ------------------
 1014|      0|            doReturn = -1;
 1015|    180|        else
 1016|    180|        {
 1017|    180|            switch(tmpOp->getOpType()) {
  ------------------
  |  Branch (1017:20): [True: 0, False: 180]
  ------------------
 1018|      0|                case Op::O_CHAR:
  ------------------
  |  Branch (1018:17): [True: 0, False: 180]
  ------------------
 1019|      0|                    if (!matchChar(context, tmpOp->getData(), offset, ignoreCase))
  ------------------
  |  Branch (1019:25): [True: 0, False: 0]
  ------------------
 1020|      0|                        doReturn = -1;
 1021|      0|                    else
 1022|      0|                        tmpOp = tmpOp->getNextOp();
 1023|      0|                    break;
 1024|      0|                case Op::O_DOT:
  ------------------
  |  Branch (1024:17): [True: 0, False: 180]
  ------------------
 1025|      0|                    if (!matchDot(context, offset))
  ------------------
  |  Branch (1025:25): [True: 0, False: 0]
  ------------------
 1026|      0|                        doReturn = -1;
 1027|      0|                    else
 1028|      0|                        tmpOp = tmpOp->getNextOp();
 1029|      0|                    break;
 1030|    148|                case Op::O_RANGE:
  ------------------
  |  Branch (1030:17): [True: 148, False: 32]
  ------------------
 1031|    148|                case Op::O_NRANGE:
  ------------------
  |  Branch (1031:17): [True: 0, False: 180]
  ------------------
 1032|    148|                    if (!matchRange(context, tmpOp, offset, ignoreCase))
  ------------------
  |  Branch (1032:25): [True: 27, False: 121]
  ------------------
 1033|     27|                        doReturn = -1;
 1034|    121|                    else
 1035|    121|                        tmpOp = tmpOp->getNextOp();
 1036|    148|                    break;
 1037|      0|                case Op::O_ANCHOR:
  ------------------
  |  Branch (1037:17): [True: 0, False: 180]
  ------------------
 1038|      0|                    if (!matchAnchor(context, tmpOp->getData(), offset))
  ------------------
  |  Branch (1038:25): [True: 0, False: 0]
  ------------------
 1039|      0|                        doReturn = -1;
 1040|      0|                    else
 1041|      0|                        tmpOp = tmpOp->getNextOp();
 1042|      0|                    break;
 1043|      0|                case Op::O_BACKREFERENCE:
  ------------------
  |  Branch (1043:17): [True: 0, False: 180]
  ------------------
 1044|      0|                    if (!matchBackReference(context, tmpOp->getData(), offset,
  ------------------
  |  Branch (1044:25): [True: 0, False: 0]
  ------------------
 1045|      0|                                            ignoreCase))
 1046|      0|                        doReturn = -1;
 1047|      0|                    else
 1048|      0|                        tmpOp = tmpOp->getNextOp();
 1049|      0|                    break;
 1050|      0|                case Op::O_STRING:
  ------------------
  |  Branch (1050:17): [True: 0, False: 180]
  ------------------
 1051|      0|                    if (!matchString(context, tmpOp->getLiteral(), offset, ignoreCase))
  ------------------
  |  Branch (1051:25): [True: 0, False: 0]
  ------------------
 1052|      0|                        doReturn = -1;
 1053|      0|                    else
 1054|      0|                        tmpOp = tmpOp->getNextOp();
 1055|      0|                    break;
 1056|     16|                case Op::O_FINITE_CLOSURE:
  ------------------
  |  Branch (1056:17): [True: 16, False: 164]
  ------------------
 1057|     16|                {
 1058|     16|                    XMLInt32 id = tmpOp->getData();
 1059|       |                    // if id is not -1, it's a closure with a child token having a minumum length,
 1060|       |                    // where id is the index of the fOffsets array where its status is stored
 1061|     16|                    if (id >= 0) {
  ------------------
  |  Branch (1061:25): [True: 0, False: 16]
  ------------------
 1062|      0|                        int prevOffset = context->fOffsets[id];
 1063|      0|                        if (prevOffset < 0 || prevOffset != (int)offset) {
  ------------------
  |  Branch (1063:29): [True: 0, False: 0]
  |  Branch (1063:47): [True: 0, False: 0]
  ------------------
 1064|      0|                            context->fOffsets[id] = (int)offset;
 1065|      0|                        }
 1066|      0|                        else {
 1067|       |                            // the status didn't change, we haven't found other copies; move on to the next match
 1068|      0|                            context->fOffsets[id] = -1;
 1069|      0|                            tmpOp = tmpOp->getNextOp();
 1070|      0|                            break;
 1071|      0|                        }
 1072|      0|                    }
 1073|       |
 1074|       |                    // match the subitems until they do
 1075|     16|                    int ret;
 1076|    116|                    while((ret = match(context, tmpOp->getChild(), offset)) != -1)
  ------------------
  |  Branch (1076:27): [True: 100, False: 16]
  ------------------
 1077|    100|                    {
 1078|    100|                        if(offset == (XMLSize_t)ret)
  ------------------
  |  Branch (1078:28): [True: 0, False: 100]
  ------------------
 1079|      0|                            break;
 1080|    100|                        offset = ret;
 1081|    100|                    }
 1082|       |
 1083|     16|                    if (id >= 0) {
  ------------------
  |  Branch (1083:25): [True: 0, False: 16]
  ------------------
 1084|       |                        // loop has ended, reset the status for this closure
 1085|      0|                        context->fOffsets[id] = -1;
 1086|      0|                    }
 1087|     16|                    tmpOp = tmpOp->getNextOp();
 1088|     16|                }
 1089|      0|                break;
 1090|      0|                case Op::O_FINITE_NONGREEDYCLOSURE:
  ------------------
  |  Branch (1090:17): [True: 0, False: 180]
  ------------------
 1091|      0|                {
 1092|      0|                    int ret = match(context,tmpOp->getNextOp(),offset);
 1093|      0|                    if (ret >= 0)
  ------------------
  |  Branch (1093:25): [True: 0, False: 0]
  ------------------
 1094|      0|                        doReturn = ret;
 1095|      0|                    else
 1096|      0|                    {
 1097|       |                        // match the subitems until they do
 1098|      0|                        int ret;
 1099|      0|                        while((ret = match(context, tmpOp->getChild(), offset)) != -1)
  ------------------
  |  Branch (1099:31): [True: 0, False: 0]
  ------------------
 1100|      0|                        {
 1101|      0|                            if(offset == (XMLSize_t)ret)
  ------------------
  |  Branch (1101:32): [True: 0, False: 0]
  ------------------
 1102|      0|                                break;
 1103|      0|                            offset = ret;
 1104|      0|                        }
 1105|      0|                        tmpOp = tmpOp->getNextOp();
 1106|      0|                    }
 1107|      0|                }
 1108|      0|                break;
 1109|      0|                case Op::O_CLOSURE:
  ------------------
  |  Branch (1109:17): [True: 0, False: 180]
  ------------------
 1110|      0|                {
 1111|      0|                    XMLInt32 id = tmpOp->getData();
 1112|       |                    // if id is not -1, it's a closure with a child token having a minumum length,
 1113|       |                    // where id is the index of the fOffsets array where its status is stored
 1114|      0|                    if (id >= 0) {
  ------------------
  |  Branch (1114:25): [True: 0, False: 0]
  ------------------
 1115|      0|                        int prevOffset = context->fOffsets[id];
 1116|      0|                        if (prevOffset < 0 || prevOffset != (int)offset) {
  ------------------
  |  Branch (1116:29): [True: 0, False: 0]
  |  Branch (1116:47): [True: 0, False: 0]
  ------------------
 1117|      0|                            context->fOffsets[id] = (int)offset;
 1118|      0|                        }
 1119|      0|                        else {
 1120|       |                            // the status didn't change, we haven't found other copies; move on to the next match
 1121|      0|                            context->fOffsets[id] = -1;
 1122|      0|                            tmpOp = tmpOp->getNextOp();
 1123|      0|                            break;
 1124|      0|                        }
 1125|      0|                    }
 1126|       |
 1127|      0|                    if(opStack!=NULL)
  ------------------
  |  Branch (1127:24): [True: 0, False: 0]
  ------------------
 1128|      0|                    {
 1129|      0|                        opStack->push(RE_RuntimeContext(tmpOp, offset));
 1130|      0|                        tmpOp = tmpOp->getChild();
 1131|      0|                    }
 1132|      0|                    else
 1133|      0|                    {
 1134|      0|                        int ret = match(context, tmpOp->getChild(), offset);
 1135|      0|                        if (id >= 0) {
  ------------------
  |  Branch (1135:29): [True: 0, False: 0]
  ------------------
 1136|      0|                            context->fOffsets[id] = -1;
 1137|      0|                        }
 1138|      0|                        if (ret >= 0)
  ------------------
  |  Branch (1138:29): [True: 0, False: 0]
  ------------------
 1139|      0|                            doReturn = ret;
 1140|      0|                        else
 1141|      0|                            tmpOp = tmpOp->getNextOp();
 1142|      0|                    }
 1143|      0|                }
 1144|      0|                break;
 1145|      0|                case Op::O_QUESTION:
  ------------------
  |  Branch (1145:17): [True: 0, False: 180]
  ------------------
 1146|      0|                {
 1147|      0|                    if(opStack!=NULL)
  ------------------
  |  Branch (1147:24): [True: 0, False: 0]
  ------------------
 1148|      0|                    {
 1149|      0|                        opStack->push(RE_RuntimeContext(tmpOp, offset));
 1150|      0|                        tmpOp = tmpOp->getChild();
 1151|      0|                    }
 1152|      0|                    else
 1153|      0|                    {
 1154|      0|                        int ret = match(context, tmpOp->getChild(), offset);
 1155|      0|                        if (ret >= 0)
  ------------------
  |  Branch (1155:29): [True: 0, False: 0]
  ------------------
 1156|      0|                            doReturn = ret;
 1157|      0|                        else
 1158|      0|                            tmpOp = tmpOp->getNextOp();
 1159|      0|                    }
 1160|      0|                }
 1161|      0|                break;
 1162|      0|                case Op::O_NONGREEDYCLOSURE:
  ------------------
  |  Branch (1162:17): [True: 0, False: 180]
  ------------------
 1163|      0|                case Op::O_NONGREEDYQUESTION:
  ------------------
  |  Branch (1163:17): [True: 0, False: 180]
  ------------------
 1164|      0|                {
 1165|      0|                    int ret = match(context,tmpOp->getNextOp(),offset);
 1166|      0|                    if (ret >= 0)
  ------------------
  |  Branch (1166:25): [True: 0, False: 0]
  ------------------
 1167|      0|                        doReturn = ret;
 1168|      0|                    else
 1169|      0|                        tmpOp = tmpOp->getChild();
 1170|      0|                }
 1171|      0|                break;
 1172|     16|                case Op::O_UNION:
  ------------------
  |  Branch (1172:17): [True: 16, False: 164]
  ------------------
 1173|     16|                    doReturn = matchUnion(context, tmpOp, offset);
 1174|     16|                    break;
 1175|      0|                case Op::O_CAPTURE:
  ------------------
  |  Branch (1175:17): [True: 0, False: 180]
  ------------------
 1176|      0|                    if (context->fMatch != 0 && tmpOp->getData() != 0)
  ------------------
  |  Branch (1176:25): [True: 0, False: 0]
  |  Branch (1176:49): [True: 0, False: 0]
  ------------------
 1177|      0|                        doReturn = matchCapture(context, tmpOp, offset);
 1178|      0|                    else
 1179|      0|                        tmpOp = tmpOp->getNextOp();
 1180|      0|                    break;
 1181|    180|            }
 1182|    180|        }
 1183|    180|        if (doReturn != -5) {
  ------------------
  |  Branch (1183:13): [True: 43, False: 137]
  ------------------
 1184|     43|            if (opStack==NULL || opStack->size() == 0)
  ------------------
  |  Branch (1184:17): [True: 43, False: 0]
  |  Branch (1184:34): [True: 0, False: 0]
  ------------------
 1185|     43|                return doReturn;
 1186|      0|            RE_RuntimeContext ctx = opStack->pop();
 1187|      0|            tmpOp = ctx.op_;
 1188|      0|            offset = ctx.offs_;
 1189|      0|            if (tmpOp->getOpType() == Op::O_CLOSURE) {
  ------------------
  |  Branch (1189:17): [True: 0, False: 0]
  ------------------
 1190|      0|                XMLInt32 id = tmpOp->getData();
 1191|      0|                if (id >= 0) {
  ------------------
  |  Branch (1191:21): [True: 0, False: 0]
  ------------------
 1192|       |                    // loop has ended, reset the status for this closure
 1193|      0|                    context->fOffsets[id] = -1;
 1194|      0|                }
 1195|      0|            }
 1196|      0|            if (tmpOp->getOpType() == Op::O_CLOSURE || tmpOp->getOpType() == Op::O_QUESTION) {
  ------------------
  |  Branch (1196:17): [True: 0, False: 0]
  |  Branch (1196:56): [True: 0, False: 0]
  ------------------
 1197|      0|                if (doReturn >= 0)
  ------------------
  |  Branch (1197:21): [True: 0, False: 0]
  ------------------
 1198|      0|                    return doReturn;
 1199|      0|            }
 1200|      0|            tmpOp = tmpOp->getNextOp();
 1201|      0|        }
 1202|    180|    }
 1203|       |
 1204|    116|    return (int)offset;
 1205|    159|}
_ZNK11xercesc_3_217RegularExpression10matchRangeEPNS0_7ContextEPKNS_2OpERmb:
 1251|    148|{
 1252|    148|    if (offset >= context->fLimit)
  ------------------
  |  Branch (1252:9): [True: 16, False: 132]
  ------------------
 1253|     16|        return false;
 1254|       |
 1255|    132|    XMLInt32 strCh = 0;
 1256|       |
 1257|    132|    if (!context->nextCh(strCh, offset))
  ------------------
  |  Branch (1257:9): [True: 0, False: 132]
  ------------------
 1258|      0|        return false;
 1259|       |
 1260|    132|    RangeToken* tok = (RangeToken *) op->getToken();
 1261|    132|    bool match = false;
 1262|       |
 1263|    132|    if (ignoreCase) {
  ------------------
  |  Branch (1263:9): [True: 0, False: 132]
  ------------------
 1264|      0|        tok = tok->getCaseInsensitiveToken(fTokenFactory);
 1265|      0|    }
 1266|       |
 1267|    132|    match = tok->match(strCh);
 1268|       |
 1269|    132|    if (!match)
  ------------------
  |  Branch (1269:9): [True: 11, False: 121]
  ------------------
 1270|     11|        return false;
 1271|       |
 1272|    121|    ++offset;
 1273|    121|    return true;
 1274|    132|}
_ZNK11xercesc_3_217RegularExpression10matchUnionEPNS0_7ContextEPKNS_2OpEm:
 1385|     16|{
 1386|     16|    XMLSize_t opSize = op->getSize();
 1387|       |
 1388|     16|    Context bestResultContext;
 1389|     16|    int bestResult=-1;
 1390|     27|    for(XMLSize_t i=0; i < opSize; i++) {
  ------------------
  |  Branch (1390:24): [True: 27, False: 0]
  ------------------
 1391|     27|        Context tmpContext(context);
 1392|     27|        int ret = match(&tmpContext, op->elementAt(i), offset);
 1393|     27|        if (ret >= 0 && (XMLSize_t)ret <= context->fLimit && ret>bestResult)
  ------------------
  |  Branch (1393:13): [True: 16, False: 11]
  |  Branch (1393:25): [True: 16, False: 0]
  |  Branch (1393:62): [True: 16, False: 0]
  ------------------
 1394|     16|        {
 1395|     16|            bestResult=ret;
 1396|     16|            bestResultContext=tmpContext;
 1397|       |            // exit early, if we reached the end of the string
 1398|     16|            if((XMLSize_t)ret == context->fLimit)
  ------------------
  |  Branch (1398:16): [True: 16, False: 0]
  ------------------
 1399|     16|                break;
 1400|     16|        }
 1401|     27|    }
 1402|     16|    if(bestResult!=-1)
  ------------------
  |  Branch (1402:8): [True: 16, False: 0]
  ------------------
 1403|     16|        *context=bestResultContext;
 1404|     16|    return bestResult;
 1405|     16|}
_ZN11xercesc_3_217RegularExpression12parseOptionsEPKDs:
 1409|      4|{
 1410|       |
 1411|      4|    if (options == 0)
  ------------------
  |  Branch (1411:9): [True: 0, False: 4]
  ------------------
 1412|      0|        return 0;
 1413|       |
 1414|      4|    int opts = 0;
 1415|      4|    XMLSize_t length = XMLString::stringLen(options);
 1416|       |
 1417|      8|    for (XMLSize_t i=0; i < length; i++) {
  ------------------
  |  Branch (1417:25): [True: 4, False: 4]
  ------------------
 1418|       |
 1419|      4|        int v = getOptionValue(options[i]);
 1420|       |
 1421|      4|        if (v == 0)
  ------------------
  |  Branch (1421:13): [True: 0, False: 4]
  ------------------
 1422|      0|            ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Regex_UnknownOption, options, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
 1423|       |
 1424|      4|        opts |= v;
 1425|      4|    }
 1426|       |
 1427|      4|    return opts;
 1428|      4|}
_ZN11xercesc_3_217RegularExpression7compileEPKNS_5TokenE:
 1430|      4|void RegularExpression::compile(const Token* const token) {
 1431|       |
 1432|      4|    if (fOperations != 0)
  ------------------
  |  Branch (1432:9): [True: 0, False: 4]
  ------------------
 1433|      0|        return;
 1434|       |
 1435|      4|    fNoClosures = 0;
 1436|      4|    fOperations = compile(token, 0, false);
 1437|      4|}
_ZN11xercesc_3_217RegularExpression7compileEPKNS_5TokenEPNS_2OpEb:
 1441|     59|{
 1442|       |
 1443|     59|    Op* ret = 0;
 1444|       |
 1445|     59|    const Token::tokType tokenType = token->getTokenType();
 1446|       |
 1447|     59|    switch(tokenType) {
 1448|      0|    case Token::T_DOT:
  ------------------
  |  Branch (1448:5): [True: 0, False: 59]
  ------------------
 1449|      0|        ret = fOpFactory.createDotOp();
 1450|      0|        ret->setNextOp(next);
 1451|      0|        break;
 1452|      2|    case Token::T_CHAR:
  ------------------
  |  Branch (1452:5): [True: 2, False: 57]
  ------------------
 1453|      2|        ret = fOpFactory.createCharOp(token->getChar());
 1454|      2|        ret->setNextOp(next);
 1455|      2|        break;
 1456|      0|    case Token::T_ANCHOR:
  ------------------
  |  Branch (1456:5): [True: 0, False: 59]
  ------------------
 1457|      0|        ret = fOpFactory.createAnchorOp(token->getChar());
 1458|      0|        ret->setNextOp(next);
 1459|      0|        break;
 1460|     37|    case Token::T_RANGE:
  ------------------
  |  Branch (1460:5): [True: 37, False: 22]
  ------------------
 1461|     37|    case Token::T_NRANGE:
  ------------------
  |  Branch (1461:5): [True: 0, False: 59]
  ------------------
 1462|     37|        ret = fOpFactory.createRangeOp(token);
 1463|     37|        ret->setNextOp(next);
 1464|     37|        break;
 1465|      0|    case Token::T_STRING:
  ------------------
  |  Branch (1465:5): [True: 0, False: 59]
  ------------------
 1466|      0|        ret = fOpFactory.createStringOp(token->getString());
 1467|      0|        ret->setNextOp(next);
 1468|      0|        break;
 1469|      0|    case Token::T_BACKREFERENCE:
  ------------------
  |  Branch (1469:5): [True: 0, False: 59]
  ------------------
 1470|      0|        ret = fOpFactory.createBackReferenceOp(token->getReferenceNo());
 1471|      0|        ret->setNextOp(next);
 1472|      0|        break;
 1473|      1|    case Token::T_EMPTY:
  ------------------
  |  Branch (1473:5): [True: 1, False: 58]
  ------------------
 1474|      1|        ret = next;
 1475|      1|        break;
 1476|      6|    case Token::T_CONCAT:
  ------------------
  |  Branch (1476:5): [True: 6, False: 53]
  ------------------
 1477|      6|        ret = compileConcat(token, next, reverse);
 1478|      6|        break;
 1479|      1|    case Token::T_UNION:
  ------------------
  |  Branch (1479:5): [True: 1, False: 58]
  ------------------
 1480|      1|        ret = compileUnion(token, next, reverse);
 1481|      1|        break;
 1482|      8|    case Token::T_CLOSURE:
  ------------------
  |  Branch (1482:5): [True: 8, False: 51]
  ------------------
 1483|      8|    case Token::T_NONGREEDYCLOSURE:
  ------------------
  |  Branch (1483:5): [True: 0, False: 59]
  ------------------
 1484|      8|        ret = compileClosure(token, next, reverse, tokenType);
 1485|      8|        break;
 1486|      4|    case Token::T_PAREN:
  ------------------
  |  Branch (1486:5): [True: 4, False: 55]
  ------------------
 1487|      4|        ret = compileParenthesis(token, next, reverse);
 1488|      4|        break;
 1489|      0|    default:
  ------------------
  |  Branch (1489:5): [True: 0, False: 59]
  ------------------
 1490|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Regex_UnknownTokenType, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1491|      0|        break; // this line to be deleted
 1492|     59|    }
 1493|       |
 1494|     59|    return ret;
 1495|     59|}
_ZN11xercesc_3_217RegularExpression7prepareEv:
 1500|      4|void RegularExpression::prepare() {
 1501|       |
 1502|      4|    compile(fTokenTree);
 1503|       |
 1504|      4|    fMinLength = fTokenTree->getMinLength();
 1505|      4|    fFirstChar = 0;
 1506|       |
 1507|      4|    if (!isSet(fOptions, PROHIBIT_HEAD_CHARACTER_OPTIMIZATION) &&
  ------------------
  |  Branch (1507:9): [True: 4, False: 0]
  ------------------
 1508|      4|        !isSet(fOptions, XMLSCHEMA_MODE))                            {
  ------------------
  |  Branch (1508:9): [True: 0, False: 4]
  ------------------
 1509|       |
 1510|      0|        RangeToken* rangeTok = fTokenFactory->createRange();
 1511|      0|        Token::firstCharacterOptions result = fTokenTree->analyzeFirstCharacter(rangeTok, fOptions, fTokenFactory);
 1512|       |
 1513|      0|        if (result == Token::FC_TERMINAL) {
  ------------------
  |  Branch (1513:13): [True: 0, False: 0]
  ------------------
 1514|       |
 1515|      0|            rangeTok->compactRanges();
 1516|      0|            fFirstChar = rangeTok;
 1517|      0|        }
 1518|       |
 1519|      0|        rangeTok->createMap();
 1520|       |
 1521|      0|        if (isSet(fOptions, IGNORE_CASE))
  ------------------
  |  Branch (1521:13): [True: 0, False: 0]
  ------------------
 1522|      0|        {
 1523|      0|            rangeTok->getCaseInsensitiveToken(fTokenFactory);
 1524|      0|        }
 1525|      0|    }
 1526|       |
 1527|      4|    if (fOperations != 0 && fOperations->getNextOp() == 0 &&
  ------------------
  |  Branch (1527:9): [True: 4, False: 0]
  |  Branch (1527:29): [True: 1, False: 3]
  ------------------
 1528|      4|        (fOperations->getOpType() == Op::O_STRING ||
  ------------------
  |  Branch (1528:10): [True: 0, False: 1]
  ------------------
 1529|      1|         fOperations->getOpType() == Op::O_CHAR) &&
  ------------------
  |  Branch (1529:10): [True: 0, False: 1]
  ------------------
 1530|      4|         !isSet(fOptions, IGNORE_CASE) )                      {
  ------------------
  |  Branch (1530:10): [True: 0, False: 0]
  ------------------
 1531|       |
 1532|      0|        fFixedStringOnly = true;
 1533|       |
 1534|      0|        if (fOperations->getOpType() == Op::O_STRING) {
  ------------------
  |  Branch (1534:13): [True: 0, False: 0]
  ------------------
 1535|      0|            fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
 1536|      0|            fFixedString = XMLString::replicate(fOperations->getLiteral(), fMemoryManager);
 1537|      0|        }
 1538|      0|        else{
 1539|       |
 1540|      0|            XMLInt32 ch = fOperations->getData();
 1541|       |
 1542|      0|            if ( ch >= 0x10000) { // add as constant
  ------------------
  |  Branch (1542:18): [True: 0, False: 0]
  ------------------
 1543|      0|                fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
 1544|      0|                fFixedString = RegxUtil::decomposeToSurrogates(ch, fMemoryManager);
 1545|      0|            }
 1546|      0|            else {
 1547|       |
 1548|      0|                XMLCh* dummyStr = (XMLCh*) fMemoryManager->allocate(2 * sizeof(XMLCh));//new XMLCh[2];
 1549|      0|                dummyStr[0] = (XMLCh) fOperations->getData();
 1550|      0|                dummyStr[1] = chNull;
 1551|      0|                fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
 1552|      0|                fFixedString = dummyStr;
 1553|      0|            }
 1554|      0|        }
 1555|       |
 1556|      0|        fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
 1557|      0|                                                    isSet(fOptions, IGNORE_CASE), fMemoryManager);
 1558|      0|    }
 1559|      4|    else if (!isSet(fOptions, XMLSCHEMA_MODE) &&
  ------------------
  |  Branch (1559:14): [True: 0, False: 4]
  ------------------
 1560|      4|             !isSet(fOptions, PROHIBIT_FIXED_STRING_OPTIMIZATION) &&
  ------------------
  |  Branch (1560:14): [True: 0, False: 0]
  ------------------
 1561|      4|             !isSet(fOptions, IGNORE_CASE)) {
  ------------------
  |  Branch (1561:14): [True: 0, False: 0]
  ------------------
 1562|       |
 1563|      0|        int fixedOpts = 0;
 1564|      0|        Token* tok = fTokenTree->findFixedString(fOptions, fixedOpts);
 1565|       |
 1566|      0|        fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
 1567|       |
 1568|      0|        fFixedString = (tok == 0) ? 0
  ------------------
  |  Branch (1568:24): [True: 0, False: 0]
  ------------------
 1569|      0|            : XMLString::replicate(tok->getString(), fMemoryManager);
 1570|       |
 1571|      0|        if (fFixedString != 0 && XMLString::stringLen(fFixedString) < 2) {
  ------------------
  |  Branch (1571:13): [True: 0, False: 0]
  |  Branch (1571:34): [True: 0, False: 0]
  ------------------
 1572|       |
 1573|      0|            fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
 1574|      0|            fFixedString = 0;
 1575|      0|        }
 1576|       |
 1577|      0|        if (fFixedString != 0) {
  ------------------
  |  Branch (1577:13): [True: 0, False: 0]
  ------------------
 1578|       |
 1579|      0|            fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
 1580|      0|                                                        isSet(fixedOpts, IGNORE_CASE), fMemoryManager);
 1581|      0|        }
 1582|      0|    }
 1583|      4|}

_ZN11xercesc_3_217RegularExpression5isSetEii:
  624|    197|  inline bool RegularExpression::isSet(const int options, const int flag) {
  625|       |
  626|    197|      return (options & flag) == flag;
  627|    197|  }
_ZN11xercesc_3_217RegularExpression12compileUnionEPKNS_5TokenEPNS_2OpEb:
  632|      1|                                             const bool reverse) {
  633|       |
  634|      1|      XMLSize_t tokSize = token->size();
  635|      1|      UnionOp* uniOp = fOpFactory.createUnionOp(tokSize);
  636|       |
  637|      3|      for (XMLSize_t i=0; i<tokSize; i++) {
  ------------------
  |  Branch (637:27): [True: 2, False: 1]
  ------------------
  638|       |
  639|      2|          uniOp->addElement(compile(token->getChild(i), next, reverse));
  640|      2|      }
  641|       |
  642|      1|      return uniOp;
  643|      1|  }
_ZN11xercesc_3_217RegularExpression18compileParenthesisEPKNS_5TokenEPNS_2OpEb:
  648|      4|                                                   const bool reverse) {
  649|       |
  650|      4|      if (token->getNoParen() == 0)
  ------------------
  |  Branch (650:11): [True: 4, False: 0]
  ------------------
  651|      4|          return compile(token->getChild(0), next, reverse);
  652|       |
  653|      0|      Op* captureOp    = 0;
  654|       |
  655|      0|      if (reverse) {
  ------------------
  |  Branch (655:11): [True: 0, False: 0]
  ------------------
  656|       |
  657|      0|          captureOp = fOpFactory.createCaptureOp(token->getNoParen(), next);
  658|      0|          captureOp = compile(token->getChild(0), captureOp, reverse);
  659|       |
  660|      0|          return fOpFactory.createCaptureOp(-token->getNoParen(), captureOp);
  661|      0|      }
  662|       |
  663|      0|      captureOp = fOpFactory.createCaptureOp(-token->getNoParen(), next);
  664|      0|      captureOp = compile(token->getChild(0), captureOp, reverse);
  665|       |
  666|      0|      return fOpFactory.createCaptureOp(token->getNoParen(), captureOp);
  667|      0|  }
_ZN11xercesc_3_217RegularExpression13compileConcatEPKNS_5TokenEPNS_2OpEb:
  671|      6|                                              const bool reverse) {
  672|       |
  673|      6|      Op* ret = next;
  674|      6|      XMLSize_t tokSize = token->size();
  675|       |
  676|      6|      if (!reverse) {
  ------------------
  |  Branch (676:11): [True: 6, False: 0]
  ------------------
  677|       |
  678|     19|          for (XMLSize_t i= tokSize; i>0; i--) {
  ------------------
  |  Branch (678:38): [True: 13, False: 6]
  ------------------
  679|     13|              ret = compile(token->getChild(i-1), ret, false);
  680|     13|          }
  681|      6|      }
  682|      0|      else {
  683|       |
  684|      0|          for (XMLSize_t i= 0; i< tokSize; i++) {
  ------------------
  |  Branch (684:32): [True: 0, False: 0]
  ------------------
  685|      0|              ret = compile(token->getChild(i), ret, true);
  686|      0|          }
  687|      0|      }
  688|       |
  689|      6|      return ret;
  690|      6|  }
_ZN11xercesc_3_217RegularExpression14compileClosureEPKNS_5TokenEPNS_2OpEbNS1_7tokTypeE:
  695|      8|                                               const Token::tokType tkType) {
  696|       |
  697|      8|      Op*    ret      = 0;
  698|      8|      Token* childTok = token->getChild(0);
  699|      8|      int    min      = token->getMin();
  700|      8|      int    max      = token->getMax();
  701|       |
  702|      8|      if (min >= 0 && min == max) {
  ------------------
  |  Branch (702:11): [True: 4, False: 4]
  |  Branch (702:23): [True: 0, False: 4]
  ------------------
  703|       |
  704|      0|          ret = next;
  705|      0|          for (int i=0; i< min; i++) {
  ------------------
  |  Branch (705:25): [True: 0, False: 0]
  ------------------
  706|      0|              ret = compile(childTok, ret, reverse);
  707|      0|          }
  708|       |
  709|      0|          return ret;
  710|      0|      }
  711|       |
  712|      8|      if (min > 0 && max > 0)
  ------------------
  |  Branch (712:11): [True: 4, False: 4]
  |  Branch (712:22): [True: 4, False: 0]
  ------------------
  713|      4|          max -= min;
  714|       |
  715|      8|      if (max > 0) {
  ------------------
  |  Branch (715:11): [True: 4, False: 4]
  ------------------
  716|       |
  717|      4|          ret = next;
  718|     32|          for (int i=0; i<max; i++) {
  ------------------
  |  Branch (718:25): [True: 28, False: 4]
  ------------------
  719|       |
  720|     28|              ChildOp* childOp = fOpFactory.createQuestionOp(
  721|     28|                  tkType == Token::T_NONGREEDYCLOSURE);
  722|       |
  723|     28|              childOp->setNextOp(next);
  724|     28|              childOp->setChild(compile(childTok, ret, reverse));
  725|     28|              ret = childOp;
  726|     28|          }
  727|      4|      }
  728|      4|      else {
  729|       |
  730|      4|          ChildOp* childOp = 0;
  731|       |
  732|      4|          if (tkType == Token::T_NONGREEDYCLOSURE) {
  ------------------
  |  Branch (732:15): [True: 0, False: 4]
  ------------------
  733|      0|              childOp = fOpFactory.createNonGreedyClosureOp();
  734|      0|          }
  735|      4|          else {
  736|       |
  737|      4|              if (childTok->getMinLength() == 0)
  ------------------
  |  Branch (737:19): [True: 0, False: 4]
  ------------------
  738|      0|                  childOp = fOpFactory.createClosureOp(fNoClosures++);
  739|      4|              else
  740|      4|                  childOp = fOpFactory.createClosureOp(-1);
  741|      4|          }
  742|       |
  743|      4|          childOp->setNextOp(next);
  744|      4|          if(next==NULL || !doTokenOverlap(next, childTok))
  ------------------
  |  Branch (744:14): [True: 4, False: 0]
  |  Branch (744:28): [True: 0, False: 0]
  ------------------
  745|      4|          {
  746|      4|              childOp->setOpType(tkType == Token::T_NONGREEDYCLOSURE?Op::O_FINITE_NONGREEDYCLOSURE:Op::O_FINITE_CLOSURE);
  ------------------
  |  Branch (746:34): [True: 0, False: 4]
  ------------------
  747|      4|              childOp->setChild(compile(childTok, NULL, reverse));
  748|      4|          }
  749|      0|          else
  750|      0|          {
  751|      0|              childOp->setChild(compile(childTok, childOp, reverse));
  752|      0|          }
  753|      4|          ret = childOp;
  754|      4|      }
  755|       |
  756|      8|      if (min > 0) {
  ------------------
  |  Branch (756:11): [True: 4, False: 4]
  ------------------
  757|       |
  758|      8|          for (int i=0; i< min; i++) {
  ------------------
  |  Branch (758:25): [True: 4, False: 4]
  ------------------
  759|      4|              ret = compile(childTok, ret, reverse);
  760|      4|          }
  761|      4|      }
  762|       |
  763|      8|      return ret;
  764|      8|  }

_ZN11xercesc_3_210RegxParserC2EPNS_13MemoryManagerE:
   63|      4|{
   64|      4|}
_ZN11xercesc_3_210RegxParserD2Ev:
   66|      4|RegxParser::~RegxParser() {
   67|       |
   68|      4|    fMemoryManager->deallocate(fString);//delete [] fString;
   69|      4|    delete fReferences;
   70|      4|}
_ZN11xercesc_3_210RegxParser5parseEPKDsi:
   75|      4|Token* RegxParser::parse(const XMLCh* const regxStr, const int options) {
   76|       |
   77|       |    // if TokenFactory is not set do nothing.
   78|       |    // REVISIT - should we throw an exception
   79|      4|    if (fTokenFactory == 0) {
  ------------------
  |  Branch (79:9): [True: 0, False: 4]
  ------------------
   80|      0|        return 0;
   81|      0|    }
   82|       |
   83|      4|    fOptions = options;
   84|      4|    fOffset = 0;
   85|      4|    fNoGroups = 1;
   86|      4|    fHasBackReferences = false;
   87|      4|    setParseContext(regexParserStateNormal);
   88|      4|    if (fString)
  ------------------
  |  Branch (88:9): [True: 0, False: 4]
  ------------------
   89|      0|        fMemoryManager->deallocate(fString);//delete [] fString;
   90|      4|    fString = XMLString::replicate(regxStr, fMemoryManager);
   91|       |
   92|      4|    if (isSet(RegularExpression::EXTENDED_COMMENT)) {
  ------------------
  |  Branch (92:9): [True: 0, False: 4]
  ------------------
   93|       |
   94|      0|        if (fString)
  ------------------
  |  Branch (94:13): [True: 0, False: 0]
  ------------------
   95|      0|            fMemoryManager->deallocate(fString);//delete [] fString;
   96|      0|        fString = RegxUtil::stripExtendedComment(regxStr, fMemoryManager);
   97|      0|    }
   98|       |
   99|      4|    fStringLen = XMLString::stringLen(fString);
  100|      4|    processNext();
  101|       |
  102|      4|    Token* retTok = parseRegx();
  103|       |
  104|      4|    if (fOffset != fStringLen) {
  ------------------
  |  Branch (104:9): [True: 0, False: 4]
  ------------------
  105|      0|        XMLCh value1[65];
  106|      0|        XMLString::sizeToText(fOffset, value1, 64, 10, fMemoryManager);
  107|      0|        ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_Parse1, value1, fString, fMemoryManager);
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  108|      0|    }
  109|       |
  110|      4|    if (fReferences != 0) {
  ------------------
  |  Branch (110:9): [True: 0, False: 4]
  ------------------
  111|       |
  112|      0|        XMLSize_t refSize = fReferences->size();
  113|      0|        for (XMLSize_t i = 0; i < refSize; i++) {
  ------------------
  |  Branch (113:31): [True: 0, False: 0]
  ------------------
  114|       |
  115|      0|            if (fNoGroups <= fReferences->elementAt(i)->fReferenceNo) {
  ------------------
  |  Branch (115:17): [True: 0, False: 0]
  ------------------
  116|      0|                ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Parse2, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  117|      0|            }
  118|      0|        }
  119|       |
  120|      0|        fReferences->removeAllElements();
  121|      0|    }
  122|       |
  123|      4|    return retTok;
  124|      4|}
_ZN11xercesc_3_210RegxParser11processNextEv:
  127|     71|void RegxParser::processNext() {
  128|       |
  129|     71|    if (fOffset >= fStringLen) {
  ------------------
  |  Branch (129:9): [True: 4, False: 67]
  ------------------
  130|       |
  131|      4|        fCharData = -1;
  132|      4|        fState = REGX_T_EOF;
  133|      4|        return;
  134|      4|    }
  135|       |
  136|     67|    parserState nextState;
  137|     67|    XMLCh ch = fString[fOffset++];
  138|     67|    fCharData = ch;
  139|       |
  140|     67|    if (fParseContext == regexParserStateInBrackets) {
  ------------------
  |  Branch (140:9): [True: 41, False: 26]
  ------------------
  141|       |
  142|     41|        switch (ch) {
  143|      1|        case chBackSlash:
  ------------------
  |  Branch (143:9): [True: 1, False: 40]
  ------------------
  144|      1|            nextState = REGX_T_BACKSOLIDUS;
  145|       |
  146|      1|            if (fOffset >= fStringLen) {
  ------------------
  |  Branch (146:17): [True: 0, False: 1]
  ------------------
  147|      0|                ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  148|      0|            }
  149|       |
  150|      1|            fCharData = fString[fOffset++];
  151|      1|            break;
  152|     11|        case chDash:
  ------------------
  |  Branch (152:9): [True: 11, False: 30]
  ------------------
  153|     11|            if (fOffset < fStringLen && fString[fOffset] == chOpenSquare) {
  ------------------
  |  Branch (153:17): [True: 11, False: 0]
  |  Branch (153:41): [True: 0, False: 11]
  ------------------
  154|       |
  155|      0|                fOffset++;
  156|      0|                nextState = REGX_T_XMLSCHEMA_CC_SUBTRACTION;
  157|      0|            }
  158|     11|            else {
  159|     11|                nextState = REGX_T_CHAR;
  160|     11|            }
  161|     11|            break;
  162|     29|        default:
  ------------------
  |  Branch (162:9): [True: 29, False: 12]
  ------------------
  163|     29|            if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
  ------------------
  |  Branch (163:17): [True: 0, False: 29]
  |  Branch (163:50): [True: 0, False: 0]
  ------------------
  164|       |
  165|      0|                XMLCh lowCh = fString[fOffset];
  166|      0|                if (RegxUtil::isLowSurrogate(lowCh)) {
  ------------------
  |  Branch (166:21): [True: 0, False: 0]
  ------------------
  167|      0|                    fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
  168|      0|                    fOffset++;
  169|      0|                }
  170|      0|                else {
  171|      0|                    throw XMLErrs::Expected2ndSurrogateChar;
  172|      0|                }
  173|      0|            }
  174|       |
  175|     29|            nextState = REGX_T_CHAR;
  176|     41|        }
  177|       |
  178|     41|        fState = nextState;
  179|     41|        return;
  180|     41|    }
  181|       |
  182|     26|    switch (ch) {
  183|       |
  184|      0|    case chPipe:
  ------------------
  |  Branch (184:5): [True: 0, False: 26]
  ------------------
  185|      0|        nextState = REGX_T_OR;
  186|      0|        break;
  187|      2|    case chAsterisk:
  ------------------
  |  Branch (187:5): [True: 2, False: 24]
  ------------------
  188|      2|        nextState = REGX_T_STAR;
  189|      2|        break;
  190|      2|    case chPlus:
  ------------------
  |  Branch (190:5): [True: 2, False: 24]
  ------------------
  191|      2|        nextState = REGX_T_PLUS;
  192|      2|        break;
  193|      1|    case chQuestion:
  ------------------
  |  Branch (193:5): [True: 1, False: 25]
  ------------------
  194|      1|        nextState = REGX_T_QUESTION;
  195|      1|        break;
  196|      4|    case chCloseParen:
  ------------------
  |  Branch (196:5): [True: 4, False: 22]
  ------------------
  197|      4|        nextState = REGX_T_RPAREN;
  198|      4|        break;
  199|      0|    case chPeriod:
  ------------------
  |  Branch (199:5): [True: 0, False: 26]
  ------------------
  200|      0|        nextState = REGX_T_DOT;
  201|      0|        break;
  202|      6|    case chOpenSquare:
  ------------------
  |  Branch (202:5): [True: 6, False: 20]
  ------------------
  203|      6|        nextState = REGX_T_LBRACKET;
  204|      6|        break;
  205|      0|    case chCaret:
  ------------------
  |  Branch (205:5): [True: 0, False: 26]
  ------------------
  206|      0|        nextState = REGX_T_CARET;
  207|      0|        break;
  208|      0|    case chDollarSign:
  ------------------
  |  Branch (208:5): [True: 0, False: 26]
  ------------------
  209|      0|        nextState = REGX_T_DOLLAR;
  210|      0|        break;
  211|      4|    case chOpenParen:
  ------------------
  |  Branch (211:5): [True: 4, False: 22]
  ------------------
  212|      4|        nextState = REGX_T_LPAREN;
  213|      4|        break;
  214|      1|    case chBackSlash:
  ------------------
  |  Branch (214:5): [True: 1, False: 25]
  ------------------
  215|      1|        nextState = REGX_T_BACKSOLIDUS;
  216|      1|        if (fOffset >= fStringLen) {
  ------------------
  |  Branch (216:13): [True: 0, False: 1]
  ------------------
  217|      0|            ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  218|      0|        }
  219|       |
  220|      1|        fCharData = fString[fOffset++];
  221|      1|        break;
  222|      6|    default:
  ------------------
  |  Branch (222:5): [True: 6, False: 20]
  ------------------
  223|      6|        nextState = REGX_T_CHAR;
  224|      6|        if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
  ------------------
  |  Branch (224:13): [True: 0, False: 6]
  |  Branch (224:46): [True: 0, False: 0]
  ------------------
  225|       |
  226|      0|                XMLCh lowCh = fString[fOffset];
  227|      0|                if (RegxUtil::isLowSurrogate(lowCh)) {
  ------------------
  |  Branch (227:21): [True: 0, False: 0]
  ------------------
  228|      0|                    fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
  229|      0|                    fOffset++;
  230|      0|                }
  231|      0|                else {
  232|      0|                    throw XMLErrs::Expected2ndSurrogateChar;
  233|      0|                }
  234|      0|            }
  235|     26|    }
  236|       |
  237|     26|    fState = nextState;
  238|     26|}
_ZN11xercesc_3_210RegxParser9parseRegxEb:
  241|      8|Token* RegxParser::parseRegx(const bool matchingRParen) {
  242|       |
  243|      8|    Token* tok = parseTerm(matchingRParen);
  244|      8|    Token* parentTok = 0;
  245|       |
  246|      8|    while (fState == REGX_T_OR) {
  ------------------
  |  Branch (246:12): [True: 0, False: 8]
  ------------------
  247|       |
  248|      0|        processNext();
  249|      0|        if (parentTok == 0) {
  ------------------
  |  Branch (249:13): [True: 0, False: 0]
  ------------------
  250|       |
  251|      0|            parentTok = fTokenFactory->createUnion();
  252|      0|            parentTok->addChild(tok, fTokenFactory);
  253|      0|            tok = parentTok;
  254|      0|        }
  255|       |
  256|      0|        tok->addChild(parseTerm(matchingRParen), fTokenFactory);
  257|      0|    }
  258|       |
  259|      8|    return tok;
  260|      8|}
_ZN11xercesc_3_210RegxParser9parseTermEb:
  263|      8|Token* RegxParser::parseTerm(const bool matchingRParen) {
  264|       |
  265|      8|    parserState state = fState;
  266|       |
  267|      8|    if (state == REGX_T_OR || state == REGX_T_EOF
  ------------------
  |  Branch (267:9): [True: 0, False: 8]
  |  Branch (267:31): [True: 0, False: 8]
  ------------------
  268|      8|        || (state == REGX_T_RPAREN && matchingRParen)) {
  ------------------
  |  Branch (268:13): [True: 0, False: 8]
  |  Branch (268:39): [True: 0, False: 0]
  ------------------
  269|      0|        return fTokenFactory->createToken(Token::T_EMPTY);
  270|      0|    }
  271|      8|    else {
  272|       |
  273|      8|        Token* tok = parseFactor();
  274|      8|        Token* concatTok = 0;
  275|       |
  276|     13|        while ((state = fState) != REGX_T_OR && state != REGX_T_EOF
  ------------------
  |  Branch (276:16): [True: 13, False: 0]
  |  Branch (276:49): [True: 9, False: 4]
  ------------------
  277|     13|               && (state != REGX_T_RPAREN || !matchingRParen))
  ------------------
  |  Branch (277:20): [True: 5, False: 4]
  |  Branch (277:46): [True: 0, False: 4]
  ------------------
  278|      5|        {
  279|      5|            if (concatTok == 0) {
  ------------------
  |  Branch (279:17): [True: 5, False: 0]
  ------------------
  280|       |
  281|      5|                concatTok = fTokenFactory->createUnion(true);
  282|      5|                concatTok->addChild(tok, fTokenFactory);
  283|      5|                tok = concatTok;
  284|      5|            }
  285|      5|            concatTok->addChild(parseFactor(), fTokenFactory);
  286|      5|        }
  287|       |
  288|      8|        return tok;
  289|      8|    }
  290|      8|}
_ZN11xercesc_3_210RegxParser11parseFactorEv:
  399|     13|Token* RegxParser::parseFactor() {
  400|       |
  401|     13|    Token* tok = parseAtom();
  402|       |
  403|     13|    switch(fState) {
  404|       |
  405|      2|    case REGX_T_STAR:
  ------------------
  |  Branch (405:5): [True: 2, False: 11]
  ------------------
  406|      2|        return processStar(tok);
  407|      2|    case REGX_T_PLUS:
  ------------------
  |  Branch (407:5): [True: 2, False: 11]
  ------------------
  408|      2|        return processPlus(tok);
  409|      1|    case REGX_T_QUESTION:
  ------------------
  |  Branch (409:5): [True: 1, False: 12]
  ------------------
  410|      1|        return processQuestion(tok);
  411|      4|    case REGX_T_CHAR:
  ------------------
  |  Branch (411:5): [True: 4, False: 9]
  ------------------
  412|      4|        if (fCharData == chOpenCurly && fOffset < fStringLen) {
  ------------------
  |  Branch (412:13): [True: 4, False: 0]
  |  Branch (412:41): [True: 4, False: 0]
  ------------------
  413|       |
  414|      4|            int min = 0;
  415|      4|            int max = -1;
  416|      4|            XMLInt32 ch = fString[fOffset++];
  417|       |
  418|      4|            if (ch >= chDigit_0 && ch <= chDigit_9) {
  ------------------
  |  Branch (418:17): [True: 4, False: 0]
  |  Branch (418:36): [True: 4, False: 0]
  ------------------
  419|       |
  420|      4|                min = ch - chDigit_0;
  421|      4|                while (fOffset < fStringLen
  ------------------
  |  Branch (421:24): [True: 4, False: 0]
  ------------------
  422|      4|                       && (ch = fString[fOffset++]) >= chDigit_0
  ------------------
  |  Branch (422:27): [True: 0, False: 4]
  ------------------
  423|      4|                       && ch <= chDigit_9) {
  ------------------
  |  Branch (423:27): [True: 0, False: 0]
  ------------------
  424|       |
  425|      0|                    min = min*10 + ch - chDigit_0;
  426|      0|                }
  427|       |
  428|      4|                if (min < 0)
  ------------------
  |  Branch (428:21): [True: 0, False: 4]
  ------------------
  429|      0|                    ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier5, fString, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  430|      4|            }
  431|      0|            else {
  432|      0|                ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier1, fString, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  433|      0|            }
  434|       |
  435|      4|            max = min;
  436|       |
  437|      4|            if (ch == chComma) {
  ------------------
  |  Branch (437:17): [True: 4, False: 0]
  ------------------
  438|       |
  439|      4|                if (fOffset >= fStringLen) {
  ------------------
  |  Branch (439:21): [True: 0, False: 4]
  ------------------
  440|      0|                    ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier3, fString, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  441|      0|                }
  442|      4|                else if ((ch = fString[fOffset++]) >= chDigit_0 && ch <= chDigit_9) {
  ------------------
  |  Branch (442:26): [True: 4, False: 0]
  |  Branch (442:68): [True: 4, False: 0]
  ------------------
  443|       |
  444|      4|                    max = ch - chDigit_0;
  445|      4|                    while (fOffset < fStringLen
  ------------------
  |  Branch (445:28): [True: 4, False: 0]
  ------------------
  446|      4|                           && (ch = fString[fOffset++]) >= chDigit_0
  ------------------
  |  Branch (446:31): [True: 4, False: 0]
  ------------------
  447|      4|                           && ch <= chDigit_9) {
  ------------------
  |  Branch (447:31): [True: 0, False: 4]
  ------------------
  448|       |
  449|      0|                        max = max*10 + ch - chDigit_0;
  450|      0|                    }
  451|       |
  452|      4|                    if (max < 0)
  ------------------
  |  Branch (452:25): [True: 0, False: 4]
  ------------------
  453|      0|                        ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier5, fString, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  454|      4|                    else if (min > max)
  ------------------
  |  Branch (454:30): [True: 0, False: 4]
  ------------------
  455|      0|                        ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier4, fString, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  456|      4|                }
  457|      0|                else {
  458|      0|                    max = -1;
  459|      0|                }
  460|      4|            }
  461|       |
  462|      4|            if (ch != chCloseCurly)  {
  ------------------
  |  Branch (462:17): [True: 0, False: 4]
  ------------------
  463|      0|                ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier2, fString, fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  464|      0|            }
  465|       |
  466|      4|            if (checkQuestion(fOffset)) {
  ------------------
  |  Branch (466:17): [True: 0, False: 4]
  ------------------
  467|       |
  468|      0|                tok = fTokenFactory->createClosure(tok, true);
  469|      0|                fOffset++;
  470|      0|            }
  471|      4|            else {
  472|      4|                tok = fTokenFactory->createClosure(tok);
  473|      4|            }
  474|       |
  475|      4|            tok->setMin(min);
  476|      4|            tok->setMax(max);
  477|      4|            processNext();
  478|      4|        }
  479|      4|        break;
  480|      4|    default:
  ------------------
  |  Branch (480:5): [True: 4, False: 9]
  ------------------
  481|      4|        break;
  482|     13|    }
  483|       |
  484|      8|    return tok;
  485|     13|}
_ZN11xercesc_3_210RegxParser9parseAtomEv:
  488|     13|Token* RegxParser::parseAtom() {
  489|       |
  490|     13|    Token* tok = 0;
  491|       |
  492|     13|    switch(fState) {
  493|       |
  494|      4|    case REGX_T_LPAREN:
  ------------------
  |  Branch (494:5): [True: 4, False: 9]
  ------------------
  495|      4|        return processParen();
  496|      0|    case REGX_T_DOT:
  ------------------
  |  Branch (496:5): [True: 0, False: 13]
  ------------------
  497|      0|        processNext();
  498|      0|        tok = fTokenFactory->getDot();
  499|      0|        break;
  500|      0|    case REGX_T_CARET:
  ------------------
  |  Branch (500:5): [True: 0, False: 13]
  ------------------
  501|      0|        return processCaret();
  502|      0|    case REGX_T_DOLLAR:
  ------------------
  |  Branch (502:5): [True: 0, False: 13]
  ------------------
  503|      0|        return processDollar();
  504|      6|    case REGX_T_LBRACKET:
  ------------------
  |  Branch (504:5): [True: 6, False: 7]
  ------------------
  505|      6|        return parseCharacterClass(true);
  506|      1|    case REGX_T_BACKSOLIDUS:
  ------------------
  |  Branch (506:5): [True: 1, False: 12]
  ------------------
  507|      1|        switch(fCharData) {
  508|       |
  509|      0|        case chLatin_d:
  ------------------
  |  Branch (509:9): [True: 0, False: 1]
  ------------------
  510|      0|        case chLatin_D:
  ------------------
  |  Branch (510:9): [True: 0, False: 1]
  ------------------
  511|      0|        case chLatin_w:
  ------------------
  |  Branch (511:9): [True: 0, False: 1]
  ------------------
  512|      0|        case chLatin_W:
  ------------------
  |  Branch (512:9): [True: 0, False: 1]
  ------------------
  513|      0|        case chLatin_s:
  ------------------
  |  Branch (513:9): [True: 0, False: 1]
  ------------------
  514|      0|        case chLatin_S:
  ------------------
  |  Branch (514:9): [True: 0, False: 1]
  ------------------
  515|      1|        case chLatin_c:
  ------------------
  |  Branch (515:9): [True: 1, False: 0]
  ------------------
  516|      1|        case chLatin_C:
  ------------------
  |  Branch (516:9): [True: 0, False: 1]
  ------------------
  517|      1|        case chLatin_i:
  ------------------
  |  Branch (517:9): [True: 0, False: 1]
  ------------------
  518|      1|        case chLatin_I:
  ------------------
  |  Branch (518:9): [True: 0, False: 1]
  ------------------
  519|      1|            tok = getTokenForShorthand(fCharData);
  520|      1|            processNext();
  521|      1|            return tok;
  522|      0|        case chDigit_0:
  ------------------
  |  Branch (522:9): [True: 0, False: 1]
  ------------------
  523|      0|        case chDigit_1:
  ------------------
  |  Branch (523:9): [True: 0, False: 1]
  ------------------
  524|      0|        case chDigit_2:
  ------------------
  |  Branch (524:9): [True: 0, False: 1]
  ------------------
  525|      0|        case chDigit_3:
  ------------------
  |  Branch (525:9): [True: 0, False: 1]
  ------------------
  526|      0|        case chDigit_4:
  ------------------
  |  Branch (526:9): [True: 0, False: 1]
  ------------------
  527|      0|        case chDigit_5:
  ------------------
  |  Branch (527:9): [True: 0, False: 1]
  ------------------
  528|      0|        case chDigit_6:
  ------------------
  |  Branch (528:9): [True: 0, False: 1]
  ------------------
  529|      0|        case chDigit_7:
  ------------------
  |  Branch (529:9): [True: 0, False: 1]
  ------------------
  530|      0|        case chDigit_8:
  ------------------
  |  Branch (530:9): [True: 0, False: 1]
  ------------------
  531|      0|        case chDigit_9:
  ------------------
  |  Branch (531:9): [True: 0, False: 1]
  ------------------
  532|      0|            return processBackReference();
  533|      0|        case chLatin_p:
  ------------------
  |  Branch (533:9): [True: 0, False: 1]
  ------------------
  534|      0|        case chLatin_P:
  ------------------
  |  Branch (534:9): [True: 0, False: 1]
  ------------------
  535|      0|            {                
  536|      0|                tok = processBacksolidus_pP(fCharData);
  537|      0|                if (tok == 0) {
  ------------------
  |  Branch (537:21): [True: 0, False: 0]
  ------------------
  538|      0|                    ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom5, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  539|      0|                }
  540|      0|            }
  541|      0|            break;
  542|      0|        default:
  ------------------
  |  Branch (542:9): [True: 0, False: 1]
  ------------------
  543|      0|            {
  544|      0|                XMLInt32 ch = decodeEscaped();
  545|      0|                if (ch < 0x10000) {
  ------------------
  |  Branch (545:21): [True: 0, False: 0]
  ------------------
  546|      0|                    tok = fTokenFactory->createChar(ch);
  547|      0|                }
  548|      0|                else {
  549|       |
  550|      0|                    XMLCh* surrogateStr = RegxUtil::decomposeToSurrogates(ch, fMemoryManager);
  551|      0|                    ArrayJanitor<XMLCh> janSurrogate(surrogateStr, fMemoryManager);
  552|      0|                    tok = fTokenFactory->createString(surrogateStr);
  553|      0|                }
  554|      0|            }
  555|      0|            break;
  556|      1|        } // end switch
  557|       |
  558|      0|        processNext();
  559|      0|        break;
  560|      2|    case REGX_T_CHAR:
  ------------------
  |  Branch (560:5): [True: 2, False: 11]
  ------------------
  561|      2|        if (fCharData == chOpenCurly
  ------------------
  |  Branch (561:13): [True: 0, False: 2]
  ------------------
  562|      2|            || fCharData == chCloseCurly
  ------------------
  |  Branch (562:16): [True: 0, False: 2]
  ------------------
  563|      2|            || fCharData == chCloseSquare)
  ------------------
  |  Branch (563:16): [True: 0, False: 2]
  ------------------
  564|      0|            ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom4, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  565|       |
  566|      2|        tok = fTokenFactory->createChar(fCharData);
  567|      2|        processNext();
  568|      2|        break;
  569|      0|    default:
  ------------------
  |  Branch (569:5): [True: 0, False: 13]
  ------------------
  570|      0|        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom4, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  571|     13|    } //end switch
  572|       |
  573|      2|    return tok;
  574|     13|}
_ZN11xercesc_3_210RegxParser19parseCharacterClassEb:
  601|      6|RangeToken* RegxParser::parseCharacterClass(const bool useNRange) {
  602|       |
  603|      6|    setParseContext(regexParserStateInBrackets);
  604|      6|    processNext();
  605|       |
  606|      6|    RangeToken* tok = 0;
  607|      6|    bool isNRange = false;
  608|       |
  609|      6|    if (getState() == REGX_T_CHAR && getCharData() == chCaret) {
  ------------------
  |  Branch (609:9): [True: 6, False: 0]
  |  Branch (609:38): [True: 0, False: 6]
  ------------------
  610|      0|        isNRange = true;
  611|      0|        processNext();
  612|      0|    }
  613|      6|    tok = fTokenFactory->createRange();
  614|       |
  615|      6|    parserState type;
  616|      6|    bool firstLoop = true;
  617|      6|    bool wasDecoded;
  618|       |
  619|     19|    while ( (type = getState()) != REGX_T_EOF) {
  ------------------
  |  Branch (619:13): [True: 19, False: 0]
  ------------------
  620|       |
  621|     19|        wasDecoded = false;
  622|       |
  623|       |        // single range | from-to-range | subtraction
  624|     19|        if (type == REGX_T_CHAR && getCharData() == chCloseSquare && !firstLoop)
  ------------------
  |  Branch (624:13): [True: 18, False: 1]
  |  Branch (624:36): [True: 6, False: 12]
  |  Branch (624:70): [True: 6, False: 0]
  ------------------
  625|      6|            break;
  626|       |
  627|     13|        XMLInt32 ch = getCharData();
  628|     13|        bool     end = false;
  629|       |
  630|     13|        if (type == REGX_T_BACKSOLIDUS) {
  ------------------
  |  Branch (630:13): [True: 1, False: 12]
  ------------------
  631|       |
  632|      1|            switch(ch) {
  633|      0|            case chLatin_d:
  ------------------
  |  Branch (633:13): [True: 0, False: 1]
  ------------------
  634|      0|            case chLatin_D:
  ------------------
  |  Branch (634:13): [True: 0, False: 1]
  ------------------
  635|      0|            case chLatin_w:
  ------------------
  |  Branch (635:13): [True: 0, False: 1]
  ------------------
  636|      0|            case chLatin_W:
  ------------------
  |  Branch (636:13): [True: 0, False: 1]
  ------------------
  637|      0|            case chLatin_s:
  ------------------
  |  Branch (637:13): [True: 0, False: 1]
  ------------------
  638|      0|            case chLatin_S:
  ------------------
  |  Branch (638:13): [True: 0, False: 1]
  ------------------
  639|      0|            case chLatin_i:
  ------------------
  |  Branch (639:13): [True: 0, False: 1]
  ------------------
  640|      0|            case chLatin_I:
  ------------------
  |  Branch (640:13): [True: 0, False: 1]
  ------------------
  641|      0|            case chLatin_c:
  ------------------
  |  Branch (641:13): [True: 0, False: 1]
  ------------------
  642|      0|            case chLatin_C:
  ------------------
  |  Branch (642:13): [True: 0, False: 1]
  ------------------
  643|      0|                {
  644|      0|                    tok->mergeRanges(getTokenForShorthand(ch));
  645|      0|                    end = true;
  646|      0|                }
  647|      0|                break;
  648|      0|            case chLatin_p:
  ------------------
  |  Branch (648:13): [True: 0, False: 1]
  ------------------
  649|      0|            case chLatin_P:
  ------------------
  |  Branch (649:13): [True: 0, False: 1]
  ------------------
  650|      0|                {                    
  651|      0|                    RangeToken* tok2 = processBacksolidus_pP(ch);
  652|       |
  653|      0|                    if (tok2 == 0) {
  ------------------
  |  Branch (653:25): [True: 0, False: 0]
  ------------------
  654|      0|                        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom5, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  655|      0|                    }
  656|       |
  657|      0|                    tok->mergeRanges(tok2);
  658|      0|                    end = true;
  659|      0|                }
  660|      0|                break;
  661|      1|            case chDash:
  ------------------
  |  Branch (661:13): [True: 1, False: 0]
  ------------------
  662|      1|                wasDecoded = true;
  663|       |                // fall thru to default.
  664|      1|            default:
  ------------------
  |  Branch (664:13): [True: 0, False: 1]
  ------------------
  665|      1|                ch = decodeEscaped();
  666|      1|            }
  667|      1|        } // end if REGX_T_BACKSOLIDUS
  668|     12|        else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION && !firstLoop) {
  ------------------
  |  Branch (668:18): [True: 0, False: 12]
  |  Branch (668:61): [True: 0, False: 0]
  ------------------
  669|       |
  670|      0|            if (isNRange)
  ------------------
  |  Branch (670:17): [True: 0, False: 0]
  ------------------
  671|      0|            {
  672|      0|                tok = RangeToken::complementRanges(tok, fTokenFactory, fMemoryManager);
  673|      0|                isNRange=false;
  674|      0|            }
  675|      0|            RangeToken* rangeTok = parseCharacterClass(false);
  676|      0|            tok->subtractRanges(rangeTok);
  677|       |
  678|      0|            if (getState() != REGX_T_CHAR || getCharData() != chCloseSquare) {
  ------------------
  |  Branch (678:17): [True: 0, False: 0]
  |  Branch (678:46): [True: 0, False: 0]
  ------------------
  679|      0|                ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC5, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  680|      0|            }
  681|      0|            break;
  682|      0|        } // end if REGX_T_XMLSCHEMA...
  683|       |
  684|     13|        processNext();
  685|       |
  686|     13|        if (!end) {
  ------------------
  |  Branch (686:13): [True: 13, False: 0]
  ------------------
  687|       |
  688|     13|            if (type == REGX_T_CHAR
  ------------------
  |  Branch (688:17): [True: 12, False: 1]
  ------------------
  689|     13|                && (ch == chOpenSquare
  ------------------
  |  Branch (689:21): [True: 0, False: 12]
  ------------------
  690|     12|                    || ch == chCloseSquare
  ------------------
  |  Branch (690:24): [True: 0, False: 12]
  ------------------
  691|     12|                    || (ch == chDash && getCharData() == chCloseSquare && firstLoop))) {
  ------------------
  |  Branch (691:25): [True: 0, False: 12]
  |  Branch (691:41): [True: 0, False: 0]
  |  Branch (691:75): [True: 0, False: 0]
  ------------------
  692|       |                // if regex = [-] then invalid...
  693|       |                // '[', ']', '-' not allowed and should be escaped
  694|      0|                XMLCh chStr[] = { (XMLCh)ch, chNull };
  695|      0|                ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr, getMemoryManager());
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  696|      0|            }
  697|     13|            if (ch == chDash && getCharData() == chDash && getState() != REGX_T_BACKSOLIDUS && !wasDecoded) {
  ------------------
  |  Branch (697:17): [True: 1, False: 12]
  |  Branch (697:33): [True: 0, False: 1]
  |  Branch (697:60): [True: 0, False: 0]
  |  Branch (697:96): [True: 0, False: 0]
  ------------------
  698|      0|                XMLCh chStr[] = { (XMLCh)ch, chNull };
  699|      0|                ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr, getMemoryManager());
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  700|      0|            }
  701|       |
  702|     13|            if (getState() != REGX_T_CHAR || getCharData() != chDash) {
  ------------------
  |  Branch (702:17): [True: 1, False: 12]
  |  Branch (702:46): [True: 1, False: 11]
  ------------------
  703|      2|                tok->addRange(ch, ch);
  704|      2|            }
  705|     11|            else {
  706|       |
  707|     11|                processNext();
  708|     11|                if ((type = getState()) == REGX_T_EOF)
  ------------------
  |  Branch (708:21): [True: 0, False: 11]
  ------------------
  709|      0|                    ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC2, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  710|       |
  711|     11|                if (type == REGX_T_CHAR && getCharData() == chCloseSquare) {
  ------------------
  |  Branch (711:21): [True: 11, False: 0]
  |  Branch (711:44): [True: 0, False: 11]
  ------------------
  712|      0|                    tok->addRange(ch, ch);
  713|      0|                    tok->addRange(chDash, chDash);
  714|      0|                }
  715|     11|                else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION) {
  ------------------
  |  Branch (715:26): [True: 0, False: 11]
  ------------------
  716|       |
  717|      0|                    static const XMLCh dashStr[] = { chDash, chNull};
  718|      0|                    ThrowXMLwithMemMgr2(ParseException, XMLExcepts::Parser_CC6, dashStr, dashStr, getMemoryManager());
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  719|      0|                }
  720|     11|                else {
  721|       |
  722|     11|                    XMLInt32 rangeEnd = getCharData();
  723|     11|                    XMLCh rangeEndStr[] = { (XMLCh)rangeEnd, chNull };
  724|       |
  725|     11|                    if (type == REGX_T_CHAR) {
  ------------------
  |  Branch (725:25): [True: 11, False: 0]
  ------------------
  726|       |
  727|     11|                        if (rangeEnd == chOpenSquare
  ------------------
  |  Branch (727:29): [True: 0, False: 11]
  ------------------
  728|     11|                            || rangeEnd == chCloseSquare
  ------------------
  |  Branch (728:32): [True: 0, False: 11]
  ------------------
  729|     11|                            || rangeEnd == chDash)
  ------------------
  |  Branch (729:32): [True: 0, False: 11]
  ------------------
  730|       |                            // '[', ']', '-' not allowed and should be escaped
  731|      0|                            ThrowXMLwithMemMgr2(ParseException, XMLExcepts::Parser_CC6, rangeEndStr, rangeEndStr, getMemoryManager());
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  732|     11|                    }
  733|      0|                    else if (type == REGX_T_BACKSOLIDUS) {
  ------------------
  |  Branch (733:30): [True: 0, False: 0]
  ------------------
  734|      0|                        rangeEnd = decodeEscaped();
  735|      0|                    }
  736|       |
  737|     11|                    processNext();
  738|       |
  739|     11|                    if (ch > rangeEnd) {
  ------------------
  |  Branch (739:25): [True: 0, False: 11]
  ------------------
  740|      0|                        XMLCh chStr[] = { (XMLCh)ch, chNull };
  741|      0|                        ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_Ope3, rangeEndStr, chStr, getMemoryManager());
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  742|      0|                    }
  743|       |
  744|     11|                    tok->addRange(ch, rangeEnd);
  745|     11|                }
  746|     11|            }
  747|     13|        }
  748|     13|        firstLoop = false;
  749|     13|    }
  750|       |
  751|      6|    if (getState() == REGX_T_EOF)
  ------------------
  |  Branch (751:9): [True: 0, False: 6]
  ------------------
  752|      0|        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC2, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  753|       |
  754|      6|    if (isNRange)
  ------------------
  |  Branch (754:9): [True: 0, False: 6]
  ------------------
  755|      0|    {
  756|      0|        if(useNRange)
  ------------------
  |  Branch (756:12): [True: 0, False: 0]
  ------------------
  757|      0|            tok->setTokenType(Token::T_NRANGE);
  758|      0|        else
  759|      0|            tok = RangeToken::complementRanges(tok, fTokenFactory, fMemoryManager);
  760|      0|    }
  761|       |
  762|      6|    tok->sortRanges();
  763|      6|    tok->compactRanges();
  764|       |
  765|       |    // If the case-insensitive option is enabled, we need to
  766|       |    // have the new RangeToken instance build its internal
  767|       |    // case-insensitive RangeToken.
  768|      6|    if (RegularExpression::isSet(fOptions, RegularExpression::IGNORE_CASE))
  ------------------
  |  Branch (768:9): [True: 0, False: 6]
  ------------------
  769|      0|    {
  770|      0|        tok->getCaseInsensitiveToken(fTokenFactory);
  771|      0|    }
  772|       |
  773|      6|    setParseContext(regexParserStateNormal);
  774|      6|    processNext();
  775|       |
  776|      6|    return tok;
  777|      6|}
_ZN11xercesc_3_210RegxParser20getTokenForShorthandEi:
  780|      1|RangeToken* RegxParser::getTokenForShorthand(const XMLInt32 ch) {
  781|       |
  782|      1|    switch(ch) {
  ------------------
  |  Branch (782:12): [True: 0, False: 1]
  ------------------
  783|      0|    case chLatin_d:
  ------------------
  |  Branch (783:5): [True: 0, False: 1]
  ------------------
  784|      0|        return fTokenFactory->getRange(fgUniDecimalDigit);
  785|       |        //return fTokenFactory->getRange(fgXMLDigit);
  786|      0|    case chLatin_D:
  ------------------
  |  Branch (786:5): [True: 0, False: 1]
  ------------------
  787|      0|        return fTokenFactory->getRange(fgUniDecimalDigit, true);
  788|       |        //return fTokenFactory->getRange(fgXMLDigit, true);
  789|      0|    case chLatin_w:
  ------------------
  |  Branch (789:5): [True: 0, False: 1]
  ------------------
  790|      0|        return fTokenFactory->getRange(fgXMLWord);
  791|      0|    case chLatin_W:
  ------------------
  |  Branch (791:5): [True: 0, False: 1]
  ------------------
  792|      0|        return fTokenFactory->getRange(fgXMLWord, true);
  793|      0|    case chLatin_s:
  ------------------
  |  Branch (793:5): [True: 0, False: 1]
  ------------------
  794|      0|        return fTokenFactory->getRange(fgXMLSpace);
  795|      0|    case chLatin_S:
  ------------------
  |  Branch (795:5): [True: 0, False: 1]
  ------------------
  796|      0|        return fTokenFactory->getRange(fgXMLSpace, true);
  797|      1|    case chLatin_c:
  ------------------
  |  Branch (797:5): [True: 1, False: 0]
  ------------------
  798|      1|        return fTokenFactory->getRange(fgXMLNameChar);
  799|      0|    case chLatin_C:
  ------------------
  |  Branch (799:5): [True: 0, False: 1]
  ------------------
  800|      0|        return fTokenFactory->getRange(fgXMLNameChar, true);
  801|      0|    case chLatin_i:
  ------------------
  |  Branch (801:5): [True: 0, False: 1]
  ------------------
  802|      0|        return fTokenFactory->getRange(fgXMLInitialNameChar);
  803|      0|    case chLatin_I:
  ------------------
  |  Branch (803:5): [True: 0, False: 1]
  ------------------
  804|      0|        return fTokenFactory->getRange(fgXMLInitialNameChar, true);
  805|       |//    default:
  806|       |//        ThrowXMLwithMemMgr(RuntimeException, "Invalid shorthand {0}", chAsString)
  807|      1|    }
  808|       |
  809|      0|    return 0;
  810|      1|}

_ZN11xercesc_3_210RegxParser15setTokenFactoryEPNS_12TokenFactoryE:
  238|      4|inline void RegxParser::setTokenFactory(TokenFactory* const tokFactory) {
  239|       |
  240|      4|    fTokenFactory = tokFactory;
  241|      4|}
_ZNK11xercesc_3_210RegxParser10getNoParenEv:
  201|      4|inline int RegxParser::getNoParen() const {
  202|       |
  203|      4|    return fNoGroups;
  204|      4|}
_ZNK11xercesc_3_210RegxParser17hasBackReferencesEv:
  211|      4|inline bool RegxParser::hasBackReferences() const {
  212|       |
  213|      4|    return fHasBackReferences;
  214|      4|}
_ZNK11xercesc_3_210RegxParser8getStateEv:
  191|     60|inline RegxParser::parserState RegxParser::getState() const {
  192|       |
  193|     60|    return fState;
  194|     60|}
_ZNK11xercesc_3_210RegxParser11getCharDataEv:
  196|     73|inline XMLInt32 RegxParser::getCharData() const {
  197|       |
  198|     73|    return fCharData;
  199|     73|}
_ZNK11xercesc_3_210RegxParser15getTokenFactoryEv:
  216|     11|inline TokenFactory* RegxParser::getTokenFactory() const {
  217|       |
  218|     11|    return fTokenFactory;
  219|     11|}
_ZN11xercesc_3_210RegxParser15setParseContextENS0_18parserStateContextE:
  233|     16|inline void RegxParser::setParseContext(const RegxParser::parserStateContext value) {
  234|       |
  235|     16|    fParseContext = value;
  236|     16|}
_ZN11xercesc_3_210RegxParser5isSetEi:
  251|      4|inline bool RegxParser::isSet(const int flag) {
  252|       |
  253|      4|    return (fOptions & flag) == flag;
  254|      4|}

_ZN11xercesc_3_28RegxUtil14isLowSurrogateEDs:
   75|    132|inline bool RegxUtil::isLowSurrogate(const XMLCh ch) {
   76|       |
   77|    132|    return (ch & 0xFC00) == 0xDC00;
   78|    132|}
_ZN11xercesc_3_28RegxUtil15isHighSurrogateEDs:
   80|    167|inline bool RegxUtil::isHighSurrogate(const XMLCh ch) {
   81|       |
   82|    167|    return (ch & 0xFC00) == 0xD800;
   83|    167|}

_ZN11xercesc_3_25TokenC2ENS0_7tokTypeEPNS_13MemoryManagerE:
   43|    318|{
   44|       |
   45|    318|}
_ZNK11xercesc_3_25Token12getMinLengthEv:
   55|     31|XMLSize_t Token::getMinLength() const {
   56|       |
   57|     31|    switch (fTokenType) {
  ------------------
  |  Branch (57:13): [True: 0, False: 31]
  ------------------
   58|       |
   59|      6|    case T_CONCAT:
  ------------------
  |  Branch (59:5): [True: 6, False: 25]
  ------------------
   60|      6|        {
   61|      6|            XMLSize_t sum = 0;
   62|      6|            XMLSize_t childSize = size();
   63|       |
   64|     19|            for (XMLSize_t i=0; i<childSize; i++) {
  ------------------
  |  Branch (64:33): [True: 13, False: 6]
  ------------------
   65|     13|                sum += getChild(i)->getMinLength();
   66|     13|            }
   67|      6|            return sum;
   68|      0|        }
   69|      1|    case T_UNION:
  ------------------
  |  Branch (69:5): [True: 1, False: 30]
  ------------------
   70|      1|        {
   71|      1|            XMLSize_t childSize = size();
   72|       |
   73|      1|            if (childSize == 0) {
  ------------------
  |  Branch (73:17): [True: 0, False: 1]
  ------------------
   74|      0|                return 0;
   75|      0|            }
   76|      1|            XMLSize_t ret = getChild(0)->getMinLength();
   77|       |
   78|      2|            for (XMLSize_t i=1; i < childSize; i++) {
  ------------------
  |  Branch (78:33): [True: 1, False: 1]
  ------------------
   79|       |
   80|      1|                XMLSize_t min = getChild(i)->getMinLength();
   81|      1|                if (min < ret)
  ------------------
  |  Branch (81:21): [True: 1, False: 0]
  ------------------
   82|      1|                    ret = min;
   83|      1|            }
   84|      1|            return ret;
   85|      1|        }
   86|      8|    case T_CLOSURE:
  ------------------
  |  Branch (86:5): [True: 8, False: 23]
  ------------------
   87|      8|    case T_NONGREEDYCLOSURE:
  ------------------
  |  Branch (87:5): [True: 0, False: 31]
  ------------------
   88|      8|        if (getMin() >= 0)
  ------------------
  |  Branch (88:13): [True: 4, False: 4]
  ------------------
   89|      4|            return getMin() * getChild(0)->getMinLength();
   90|       |
   91|      4|        return 0;
   92|      1|    case T_EMPTY:
  ------------------
  |  Branch (92:5): [True: 1, False: 30]
  ------------------
   93|      1|    case T_ANCHOR:
  ------------------
  |  Branch (93:5): [True: 0, False: 31]
  ------------------
   94|      1|        return 0;
   95|      0|    case T_DOT:
  ------------------
  |  Branch (95:5): [True: 0, False: 31]
  ------------------
   96|      2|    case T_CHAR:
  ------------------
  |  Branch (96:5): [True: 2, False: 29]
  ------------------
   97|     11|    case T_RANGE:
  ------------------
  |  Branch (97:5): [True: 9, False: 22]
  ------------------
   98|     11|    case T_NRANGE:
  ------------------
  |  Branch (98:5): [True: 0, False: 31]
  ------------------
   99|     11|        return 1;
  100|      4|    case T_PAREN:
  ------------------
  |  Branch (100:5): [True: 4, False: 27]
  ------------------
  101|      4|        return getChild(0)->getMinLength();
  102|      0|    case T_BACKREFERENCE:
  ------------------
  |  Branch (102:5): [True: 0, False: 31]
  ------------------
  103|      0|        return 0; // *****  - REVISIT
  104|      0|    case T_STRING:
  ------------------
  |  Branch (104:5): [True: 0, False: 31]
  ------------------
  105|      0|        return XMLString::stringLen(getString());
  106|       |//    default:
  107|       |//        throw;
  108|     31|    }
  109|       |
  110|       |    // We should not get here, but we have it to make some compilers happy
  111|      0|    return (XMLSize_t)-1;
  112|     31|}

_ZNK11xercesc_3_25Token12getTokenTypeEv:
  148|    382|inline Token::tokType Token::getTokenType() const {
  149|       |
  150|    382|    return fTokenType;
  151|    382|}

_ZN11xercesc_3_212TokenFactoryC2EPNS_13MemoryManagerE:
   47|      5|{
   48|       |
   49|      5|}
_ZN11xercesc_3_212TokenFactory11createTokenENS_5Token7tokTypeE:
   60|      1|Token* TokenFactory::createToken(const Token::tokType tkType) {
   61|       |
   62|      1|    if (tkType == Token::T_EMPTY && fEmpty != 0)
  ------------------
  |  Branch (62:9): [True: 1, False: 0]
  |  Branch (62:37): [True: 0, False: 1]
  ------------------
   63|      0|        return fEmpty;
   64|       |
   65|      1|    Token* tmpTok = new (fMemoryManager) Token(tkType, fMemoryManager);
   66|       |
   67|      1|    if (tkType == Token::T_EMPTY) {
  ------------------
  |  Branch (67:9): [True: 1, False: 0]
  ------------------
   68|      1|        fEmpty = tmpTok;
   69|      1|    }
   70|       |
   71|      1|    fTokens->addElement(tmpTok);
   72|       |
   73|      1|    return tmpTok;
   74|      1|}
_ZN11xercesc_3_212TokenFactory17createParenthesisEPNS_5TokenEi:
   78|      4|                                            const int noGroups) {
   79|       |
   80|      4|    ParenToken* tmpTok = new (fMemoryManager) ParenToken(Token::T_PAREN, token, noGroups, fMemoryManager);
   81|       |
   82|      4|    fTokens->addElement(tmpTok);
   83|      4|    return tmpTok;
   84|      4|}
_ZN11xercesc_3_212TokenFactory13createClosureEPNS_5TokenEb:
   87|      8|                                          bool isNonGreedy) {
   88|       |
   89|      8|    ClosureToken* tmpTok = isNonGreedy ? new (fMemoryManager) ClosureToken(Token::T_NONGREEDYCLOSURE, token, fMemoryManager)
  ------------------
  |  Branch (89:28): [True: 0, False: 8]
  ------------------
   90|      8|                                       : new (fMemoryManager) ClosureToken(Token::T_CLOSURE, token, fMemoryManager);
   91|       |    
   92|      8|    fTokens->addElement(tmpTok);
   93|      8|    return tmpTok;
   94|      8|}
_ZN11xercesc_3_212TokenFactory12createConcatEPNS_5TokenES2_:
   97|      2|                                        Token* const token2) {
   98|       |
   99|      2|    ConcatToken* tmpTok = new (fMemoryManager) ConcatToken(token1, token2, fMemoryManager);
  100|       |    
  101|      2|    fTokens->addElement(tmpTok);
  102|      2|    return tmpTok;
  103|      2|}
_ZN11xercesc_3_212TokenFactory11createUnionEb:
  105|      6|UnionToken* TokenFactory::createUnion(const bool isConcat) {
  106|       |
  107|      6|    UnionToken* tmpTok = isConcat ? new (fMemoryManager) UnionToken(Token::T_CONCAT, fMemoryManager)
  ------------------
  |  Branch (107:26): [True: 5, False: 1]
  ------------------
  108|      6|                                  : new (fMemoryManager) UnionToken(Token::T_UNION, fMemoryManager);
  109|       |
  110|      6|    fTokens->addElement(tmpTok);
  111|      6|    return tmpTok;
  112|      6|}
_ZN11xercesc_3_212TokenFactory11createRangeEb:
  114|    295|RangeToken* TokenFactory::createRange(const bool isNegRange){
  115|       |
  116|       |
  117|    295|    RangeToken* tmpTok = isNegRange ? new (fMemoryManager) RangeToken(Token::T_NRANGE, fMemoryManager)
  ------------------
  |  Branch (117:26): [True: 0, False: 295]
  ------------------
  118|    295|                                   : new (fMemoryManager) RangeToken(Token::T_RANGE, fMemoryManager);
  119|       |
  120|    295|    fTokens->addElement(tmpTok);
  121|    295|    return tmpTok;
  122|    295|}
_ZN11xercesc_3_212TokenFactory10createCharEjb:
  124|      2|CharToken* TokenFactory::createChar(const XMLUInt32 ch, const bool isAnchor) {
  125|       |
  126|      2|    CharToken* tmpTok = isAnchor ? new (fMemoryManager) CharToken(Token::T_ANCHOR, ch, fMemoryManager)
  ------------------
  |  Branch (126:25): [True: 0, False: 2]
  ------------------
  127|      2|                                : new (fMemoryManager) CharToken(Token::T_CHAR, ch, fMemoryManager);
  128|       |
  129|      2|    fTokens->addElement(tmpTok);
  130|      2|    return tmpTok;
  131|      2|}
_ZN11xercesc_3_212TokenFactory14staticGetRangeEPKDsb:
  153|      2|                                   const bool complement) {
  154|       |
  155|      2|    return RangeTokenMap::instance()->getRange(keyword, complement);
  156|      2|}

_ZN11xercesc_3_212TokenFactory8getRangeEPKDsb:
  118|      1|{
  119|      1|    return staticGetRange(name, complement);
  120|      1|}
_ZNK11xercesc_3_212TokenFactory16getMemoryManagerEv:
  123|     13|{
  124|     13|    return fMemoryManager;
  125|     13|}

_ZN11xercesc_3_219UnicodeRangeFactoryC2Ev:
   83|      1|{
   84|      1|}
_ZN11xercesc_3_219UnicodeRangeFactory11buildRangesEPNS_13RangeTokenMapE:
   93|      1|void UnicodeRangeFactory::buildRanges(RangeTokenMap *rangeTokMap) {
   94|       |
   95|      1|    if (fRangesCreated)
  ------------------
  |  Branch (95:9): [True: 0, False: 1]
  ------------------
   96|      0|        return;
   97|       |
   98|      1|    if (!fKeywordsInitialized) {
  ------------------
  |  Branch (98:9): [True: 0, False: 1]
  ------------------
   99|      0|        initializeKeywordMap(rangeTokMap);
  100|      0|    }
  101|       |
  102|      1|    TokenFactory* tokFactory = rangeTokMap->getTokenFactory();
  103|      1|    RangeToken* ranges[UNICATEGSIZE];
  104|      1|    RangeToken* tok;
  105|       |
  106|     38|    for (int i=0; i < UNICATEGSIZE; i++) {
  ------------------
  |  Branch (106:19): [True: 37, False: 1]
  ------------------
  107|     37|        ranges[i] = tokFactory->createRange();
  108|     37|    }
  109|       |
  110|  65.5k|    for (int j=0; j < 0x10000; j++) {
  ------------------
  |  Branch (110:19): [True: 65.5k, False: 1]
  ------------------
  111|       |
  112|  65.5k|        unsigned short charType = XMLUniCharacter::getType(j);
  113|       |
  114|  65.5k|        ranges[charType]->addRange(j, j);
  115|  65.5k|        charType = getUniCategory(charType);
  116|  65.5k|        ranges[charType]->addRange(j, j);
  117|  65.5k|    }
  118|       |
  119|      1|    ranges[XMLUniCharacter::UNASSIGNED]->addRange(0x10000, Token::UTF16_MAX);
  120|       |
  121|     38|    for (int k=0; k < UNICATEGSIZE; k++) {
  ------------------
  |  Branch (121:19): [True: 37, False: 1]
  ------------------
  122|     37|        tok = RangeToken::complementRanges(ranges[k], tokFactory);
  123|       |        // build the internal map.
  124|     37|        tok->createMap();
  125|     37|        rangeTokMap->setRangeToken(uniCategNames[k], ranges[k]);
  126|     37|        rangeTokMap->setRangeToken(uniCategNames[k], tok , true);
  127|     37|    }
  128|       |
  129|       |    // Create all range
  130|      1|    tok = tokFactory->createRange();
  131|      1|    tok->addRange(0, Token::UTF16_MAX);
  132|       |    // build the internal map.
  133|      1|    tok->createMap();
  134|      1|    rangeTokMap->setRangeToken(fgUniAll, tok);
  135|       |
  136|       |    // Create alpha range
  137|      1|    tok = tokFactory->createRange();
  138|      1|    tok->mergeRanges(ranges[XMLUniCharacter::UPPERCASE_LETTER]);
  139|      1|    tok->mergeRanges(ranges[XMLUniCharacter::LOWERCASE_LETTER]);
  140|      1|    tok->mergeRanges(ranges[XMLUniCharacter::OTHER_LETTER]);
  141|       |    // build the internal map.
  142|      1|    tok->createMap();
  143|      1|    rangeTokMap->setRangeToken(fgUniIsAlpha, tok);
  144|       |
  145|       |    // Create alpha-num range
  146|      1|    RangeToken* alnumTok = tokFactory->createRange();
  147|      1|    alnumTok->mergeRanges(tok);
  148|      1|    alnumTok->mergeRanges(ranges[XMLUniCharacter::DECIMAL_DIGIT_NUMBER]);
  149|       |    // build the internal map.
  150|      1|    alnumTok->createMap();
  151|      1|    rangeTokMap->setRangeToken(fgUniIsAlnum, alnumTok);
  152|       |
  153|       |    // Create word range
  154|      1|    tok = tokFactory->createRange();
  155|      1|    tok->mergeRanges(alnumTok);
  156|      1|    tok->addRange(chUnderscore, chUnderscore);
  157|       |    // build the internal map.
  158|      1|    tok->createMap();
  159|      1|    rangeTokMap->setRangeToken(fgUniIsWord, tok);
  160|       |
  161|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  162|       |    // build the internal map.
  163|      1|    tok->createMap();
  164|      1|    rangeTokMap->setRangeToken(fgUniIsWord, tok , true);
  165|       |
  166|       |    // Create assigned range
  167|      1|    tok = RangeToken::complementRanges(
  168|      1|                ranges[XMLUniCharacter::UNASSIGNED],
  169|      1|                tokFactory,
  170|      1|                tokFactory->getMemoryManager());
  171|       |    // build the internal map.
  172|      1|    tok->createMap();
  173|      1|    rangeTokMap->setRangeToken(fgUniAssigned,tok);
  174|       |
  175|       |    // Create space range
  176|      1|    tok = tokFactory->createRange();
  177|      1|    tok->mergeRanges(ranges[XMLUniCharacter::SPACE_SEPARATOR]);
  178|      1|    tok->mergeRanges(ranges[XMLUniCharacter::LINE_SEPARATOR]);
  179|       |    //tok->mergeRanges(ranges[XMLUniCharacter::PARAGRAPH_SEPARATOR]);
  180|       |    // build the internal map.
  181|      1|    tok->createMap();
  182|      1|    rangeTokMap->setRangeToken(fgUniIsSpace, tok);
  183|       |
  184|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  185|       |    // build the internal map.
  186|      1|    tok->createMap();
  187|      1|    rangeTokMap->setRangeToken(fgUniIsSpace, tok , true);
  188|       |
  189|      1|    RangeToken* const dummyToken =
  190|      1|        tokFactory->createRange();
  191|       |
  192|      1|    dummyToken->addRange(-1, -2);
  193|      1|    dummyToken->createMap();
  194|       |
  195|       |    // build the internal maps.
  196|     38|    for (int l=0; l < UNICATEGSIZE; l++) {
  ------------------
  |  Branch (196:19): [True: 37, False: 1]
  ------------------
  197|     37|        ranges[l]->createMap();
  198|     37|        ranges[l]->setCaseInsensitiveToken(dummyToken);
  199|     37|    }
  200|       |
  201|      1|    fRangesCreated = true;
  202|      1|}
_ZN11xercesc_3_219UnicodeRangeFactory20initializeKeywordMapEPNS_13RangeTokenMapE:
  207|      1|void UnicodeRangeFactory::initializeKeywordMap(RangeTokenMap *rangeTokMap) {
  208|       |
  209|      1|    if (fKeywordsInitialized)
  ------------------
  |  Branch (209:9): [True: 0, False: 1]
  ------------------
  210|      0|        return;
  211|       |
  212|     38|    for (int k=0; k < UNICATEGSIZE; k++) {
  ------------------
  |  Branch (212:19): [True: 37, False: 1]
  ------------------
  213|     37|        rangeTokMap->addKeywordMap(uniCategNames[k], fgUnicodeCategory);
  214|     37|    }
  215|       |
  216|      1|    rangeTokMap->addKeywordMap(fgUniAll, fgUnicodeCategory);
  217|      1|    rangeTokMap->addKeywordMap(fgUniIsAlpha, fgUnicodeCategory);
  218|      1|    rangeTokMap->addKeywordMap(fgUniIsAlnum, fgUnicodeCategory);
  219|      1|    rangeTokMap->addKeywordMap(fgUniIsWord, fgUnicodeCategory);
  220|      1|    rangeTokMap->addKeywordMap(fgUniAssigned, fgUnicodeCategory);
  221|      1|    rangeTokMap->addKeywordMap(fgUniIsSpace, fgUnicodeCategory);
  222|       |
  223|      1|    fKeywordsInitialized = true;
  224|      1|}
_ZN11xercesc_3_219UnicodeRangeFactory14getUniCategoryEt:
  230|   131k|{
  231|   131k|    switch(type) {
  ------------------
  |  Branch (231:12): [True: 0, False: 131k]
  ------------------
  232|  1.41k|    case XMLUniCharacter::UPPERCASE_LETTER:
  ------------------
  |  Branch (232:5): [True: 1.41k, False: 129k]
  ------------------
  233|  3.18k|    case XMLUniCharacter::LOWERCASE_LETTER:
  ------------------
  |  Branch (233:5): [True: 1.77k, False: 129k]
  ------------------
  234|  3.24k|    case XMLUniCharacter::TITLECASE_LETTER:
  ------------------
  |  Branch (234:5): [True: 62, False: 131k]
  ------------------
  235|  3.47k|    case XMLUniCharacter::MODIFIER_LETTER:
  ------------------
  |  Branch (235:5): [True: 228, False: 130k]
  ------------------
  236|  91.7k|    case XMLUniCharacter::OTHER_LETTER:
  ------------------
  |  Branch (236:5): [True: 88.2k, False: 42.8k]
  ------------------
  237|  91.7k|        return CHAR_LETTER;
  238|  1.06k|    case XMLUniCharacter::NON_SPACING_MARK:
  ------------------
  |  Branch (238:5): [True: 1.06k, False: 130k]
  ------------------
  239|  1.32k|    case XMLUniCharacter::COMBINING_SPACING_MARK:
  ------------------
  |  Branch (239:5): [True: 262, False: 130k]
  ------------------
  240|  1.34k|    case XMLUniCharacter::ENCLOSING_MARK:
  ------------------
  |  Branch (240:5): [True: 20, False: 131k]
  ------------------
  241|  1.34k|        return CHAR_MARK;
  242|    416|    case XMLUniCharacter::DECIMAL_DIGIT_NUMBER:
  ------------------
  |  Branch (242:5): [True: 416, False: 130k]
  ------------------
  243|    520|    case XMLUniCharacter::LETTER_NUMBER:
  ------------------
  |  Branch (243:5): [True: 104, False: 130k]
  ------------------
  244|  1.00k|    case XMLUniCharacter::OTHER_NUMBER:
  ------------------
  |  Branch (244:5): [True: 484, False: 130k]
  ------------------
  245|  1.00k|        return CHAR_NUMBER;
  246|     36|    case XMLUniCharacter::SPACE_SEPARATOR:
  ------------------
  |  Branch (246:5): [True: 36, False: 131k]
  ------------------
  247|     38|    case XMLUniCharacter::LINE_SEPARATOR:
  ------------------
  |  Branch (247:5): [True: 2, False: 131k]
  ------------------
  248|     40|    case XMLUniCharacter::PARAGRAPH_SEPARATOR:
  ------------------
  |  Branch (248:5): [True: 2, False: 131k]
  ------------------
  249|     40|        return CHAR_SEPARATOR;
  250|    130|    case XMLUniCharacter::CONTROL:
  ------------------
  |  Branch (250:5): [True: 130, False: 130k]
  ------------------
  251|    196|    case XMLUniCharacter::FORMAT:
  ------------------
  |  Branch (251:5): [True: 66, False: 131k]
  ------------------
  252|  4.29k|    case XMLUniCharacter::SURROGATE:
  ------------------
  |  Branch (252:5): [True: 4.09k, False: 126k]
  ------------------
  253|  17.0k|    case XMLUniCharacter::PRIVATE_USE:
  ------------------
  |  Branch (253:5): [True: 12.8k, False: 118k]
  ------------------
  254|  29.8k|    case XMLUniCharacter::UNASSIGNED:
  ------------------
  |  Branch (254:5): [True: 12.7k, False: 118k]
  ------------------
  255|  29.8k|        return CHAR_OTHER;
  256|     24|    case XMLUniCharacter::CONNECTOR_PUNCTUATION:
  ------------------
  |  Branch (256:5): [True: 24, False: 131k]
  ------------------
  257|     58|    case XMLUniCharacter::DASH_PUNCTUATION:
  ------------------
  |  Branch (257:5): [True: 34, False: 131k]
  ------------------
  258|    188|    case XMLUniCharacter::START_PUNCTUATION:
  ------------------
  |  Branch (258:5): [True: 130, False: 130k]
  ------------------
  259|    316|    case XMLUniCharacter::END_PUNCTUATION:
  ------------------
  |  Branch (259:5): [True: 128, False: 130k]
  ------------------
  260|    714|    case XMLUniCharacter::OTHER_PUNCTUATION:
  ------------------
  |  Branch (260:5): [True: 398, False: 130k]
  ------------------
  261|    726|    case XMLUniCharacter::INITIAL_PUNCTUATION:
  ------------------
  |  Branch (261:5): [True: 12, False: 131k]
  ------------------
  262|    734|    case XMLUniCharacter::FINAL_PUNCTUATION:
  ------------------
  |  Branch (262:5): [True: 8, False: 131k]
  ------------------
  263|    734|        return CHAR_PUNCTUATION;
  264|  1.77k|    case XMLUniCharacter::MATH_SYMBOL:
  ------------------
  |  Branch (264:5): [True: 1.77k, False: 129k]
  ------------------
  265|  1.85k|    case XMLUniCharacter::CURRENCY_SYMBOL:
  ------------------
  |  Branch (265:5): [True: 72, False: 131k]
  ------------------
  266|  1.99k|    case XMLUniCharacter::MODIFIER_SYMBOL:
  ------------------
  |  Branch (266:5): [True: 148, False: 130k]
  ------------------
  267|  6.44k|    case XMLUniCharacter::OTHER_SYMBOL:
  ------------------
  |  Branch (267:5): [True: 4.44k, False: 126k]
  ------------------
  268|  6.44k|        return CHAR_SYMBOL;
  269|   131k|    }
  270|       |
  271|      0|    return 0;
  272|   131k|}

_ZN11xercesc_3_210UnionTokenC2ENS_5Token7tokTypeEPNS_13MemoryManagerE:
   44|      6|{
   45|       |
   46|      6|}
_ZN11xercesc_3_210UnionToken8addChildEPNS_5TokenEPNS_12TokenFactoryE:
   57|     14|void UnionToken::addChild(Token* const child, TokenFactory* const tokFactory) {
   58|       |
   59|     14|    if (child == 0)
  ------------------
  |  Branch (59:9): [True: 0, False: 14]
  ------------------
   60|      0|        return;
   61|       |
   62|     14|    if (fChildren == 0)
  ------------------
  |  Branch (62:9): [True: 6, False: 8]
  ------------------
   63|      6|        fChildren = new (tokFactory->getMemoryManager()) RefVectorOf<Token>(INITIALSIZE, false, tokFactory->getMemoryManager());
   64|       |
   65|     14|    if (getTokenType() == T_UNION) {
  ------------------
  |  Branch (65:9): [True: 2, False: 12]
  ------------------
   66|       |
   67|      2|        fChildren->addElement(child);
   68|      2|        return;
   69|      2|    }
   70|       |
   71|     12|    Token::tokType childType = child->getTokenType();
   72|     12|    if (childType == T_CONCAT) {
  ------------------
  |  Branch (72:9): [True: 1, False: 11]
  ------------------
   73|       |
   74|      1|        XMLSize_t childSize = child->size();
   75|      3|        for (XMLSize_t i = 0; i < childSize; i++) {
  ------------------
  |  Branch (75:31): [True: 2, False: 1]
  ------------------
   76|       |
   77|      2|            addChild(child->getChild(i), tokFactory);
   78|      2|        }
   79|       |
   80|      1|        return;
   81|      1|    }
   82|       |
   83|     11|    XMLSize_t childrenSize = fChildren->size();
   84|     11|    if (childrenSize == 0) {
  ------------------
  |  Branch (84:9): [True: 5, False: 6]
  ------------------
   85|       |
   86|      5|        fChildren->addElement(child);
   87|      5|        return;
   88|      5|    }
   89|       |
   90|      6|    Token* previousTok = fChildren->elementAt(childrenSize - 1);
   91|      6|    Token::tokType previousType = previousTok->getTokenType();
   92|       |
   93|      6|    if (!((previousType == T_CHAR || previousType == T_STRING)
  ------------------
  |  Branch (93:12): [True: 2, False: 4]
  |  Branch (93:38): [True: 0, False: 4]
  ------------------
   94|      6|          && (childType == T_CHAR || childType == T_STRING))) {
  ------------------
  |  Branch (94:15): [True: 0, False: 2]
  |  Branch (94:38): [True: 0, False: 2]
  ------------------
   95|       |
   96|      6|        fChildren->addElement(child);
   97|      6|        return;
   98|      6|    }
   99|       |
  100|       |    // Continue
  101|      0|    XMLBuffer stringBuf(1023, tokFactory->getMemoryManager());
  102|       |
  103|      0|    if (previousType == T_CHAR) {
  ------------------
  |  Branch (103:9): [True: 0, False: 0]
  ------------------
  104|       |
  105|      0|        XMLInt32 ch = previousTok->getChar();
  106|       |
  107|      0|        if (ch >= 0x10000) {
  ------------------
  |  Branch (107:13): [True: 0, False: 0]
  ------------------
  108|       |
  109|      0|            XMLCh* chSurrogate = RegxUtil::decomposeToSurrogates(ch, tokFactory->getMemoryManager());
  110|      0|            stringBuf.append(chSurrogate);
  111|      0|            tokFactory->getMemoryManager()->deallocate(chSurrogate);//delete [] chSurrogate;
  112|      0|        }
  113|      0|        else {
  114|      0|            stringBuf.append((XMLCh) ch);
  115|      0|        }
  116|       |
  117|      0|        previousTok = tokFactory->createString(0);
  118|      0|        fChildren->setElementAt(previousTok, childrenSize - 1);
  119|      0|    }
  120|      0|    else {
  121|      0|        stringBuf.append(previousTok->getString());
  122|      0|    }
  123|       |
  124|      0|    if (childType == T_CHAR) {
  ------------------
  |  Branch (124:9): [True: 0, False: 0]
  ------------------
  125|       |
  126|      0|        XMLInt32 ch = child->getChar();
  127|       |
  128|      0|        if (ch >= 0x10000) {
  ------------------
  |  Branch (128:13): [True: 0, False: 0]
  ------------------
  129|       |
  130|      0|            XMLCh* chSurrogate = RegxUtil::decomposeToSurrogates(ch, tokFactory->getMemoryManager());
  131|      0|            stringBuf.append(chSurrogate);
  132|      0|            tokFactory->getMemoryManager()->deallocate(chSurrogate);//delete [] chSurrogate;
  133|      0|        }
  134|      0|        else {
  135|      0|            stringBuf.append((XMLCh) ch);
  136|      0|        }
  137|      0|    }
  138|      0|    else {
  139|      0|        stringBuf.append(child->getString());
  140|      0|    }
  141|       |
  142|      0|    ((StringToken*) previousTok)->setString(stringBuf.getRawBuffer());
  143|      0|}

_ZNK11xercesc_3_210UnionToken4sizeEv:
   75|     12|inline XMLSize_t UnionToken::size() const {
   76|       |
   77|     12|    return fChildren == 0 ? 0 : fChildren->size();
  ------------------
  |  Branch (77:12): [True: 0, False: 12]
  ------------------
   78|     12|}
_ZNK11xercesc_3_210UnionToken8getChildEm:
   80|     26|inline Token* UnionToken::getChild(const XMLSize_t index) const {
   81|       |
   82|     26|    return fChildren->elementAt(index);
   83|     26|}

_ZN11xercesc_3_215XMLRangeFactoryC2Ev:
   75|      1|{
   76|       |
   77|      1|}
_ZN11xercesc_3_215XMLRangeFactory11buildRangesEPNS_13RangeTokenMapE:
   86|      1|void XMLRangeFactory::buildRanges(RangeTokenMap *rangeTokMap) {
   87|       |
   88|      1|    if (fRangesCreated)
  ------------------
  |  Branch (88:9): [True: 0, False: 1]
  ------------------
   89|      0|        return;
   90|       |
   91|      1|    if (!fKeywordsInitialized) {
  ------------------
  |  Branch (91:9): [True: 0, False: 1]
  ------------------
   92|      0|        initializeKeywordMap(rangeTokMap);
   93|      0|    }
   94|       |
   95|      1|    TokenFactory* tokFactory = rangeTokMap->getTokenFactory();
   96|       |
   97|       |    // Create space ranges
   98|      1|    unsigned int wsTblLen = getTableLen(gWhitespaceChars);
   99|      1|    RangeToken* tok = tokFactory->createRange();
  100|      1|    XMLInt32* wsRange = (XMLInt32*) XMLPlatformUtils::fgMemoryManager->allocate
  101|      1|    (
  102|      1|        wsTblLen * sizeof(XMLInt32)
  103|      1|    );//new XMLInt32[wsTblLen];
  104|       |
  105|      1|    tok->setRangeValues(wsRange, wsTblLen);
  106|      1|    setupRange(wsRange, gWhitespaceChars, 0);
  107|       |    // Build the internal map.
  108|      1|    tok->createMap();
  109|      1|    rangeTokMap->setRangeToken(fgXMLSpace, tok);
  110|       |
  111|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  112|       |    // Build the internal map.
  113|      1|    tok->createMap();
  114|      1|    rangeTokMap->setRangeToken(fgXMLSpace, tok , true);
  115|       |
  116|       |    // Create digits ranges
  117|      1|    tok = tokFactory->createRange();
  118|      1|    unsigned int digitTblLen = getTableLen(gDigitChars);
  119|      1|    XMLInt32* digitRange = (XMLInt32*) XMLPlatformUtils::fgMemoryManager->allocate
  120|      1|    (
  121|      1|        digitTblLen * sizeof(XMLInt32)
  122|      1|    );//new XMLInt32[digitTblLen];
  123|       |
  124|      1|    tok->setRangeValues(digitRange, digitTblLen);
  125|      1|    setupRange(digitRange, gDigitChars, 0);
  126|       |    // Build the internal map.
  127|      1|    tok->createMap();
  128|      1|    rangeTokMap->setRangeToken(fgXMLDigit, tok);
  129|       |
  130|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  131|       |    // Build the internal map.
  132|      1|    tok->createMap();
  133|      1|    rangeTokMap->setRangeToken(fgXMLDigit, tok , true);
  134|       |
  135|       |    // Build word ranges
  136|      1|    unsigned int baseTblLen = getTableLen(gBaseChars);
  137|      1|    unsigned int ideoTblLen = getTableLen(gIdeographicChars);
  138|      1|    unsigned int wordRangeLen = baseTblLen + ideoTblLen + digitTblLen;
  139|      1|    XMLInt32* wordRange = (XMLInt32*) XMLPlatformUtils::fgMemoryManager->allocate
  140|      1|    (
  141|      1|        wordRangeLen * sizeof(XMLInt32)
  142|      1|    );//new XMLInt32[wordRangeLen];
  143|      1|    ArrayJanitor<XMLInt32> janWordRange(wordRange, XMLPlatformUtils::fgMemoryManager);
  144|       |
  145|      1|    setupRange(wordRange, gBaseChars, 0);
  146|      1|    setupRange(wordRange, gIdeographicChars, baseTblLen);
  147|      1|    memcpy(wordRange + baseTblLen + ideoTblLen, digitRange, digitTblLen * sizeof(XMLInt32));
  148|       |
  149|       |    // Create NameChar ranges
  150|      1|    tok = tokFactory->createRange();
  151|      1|    unsigned int combTblLen = getTableLen(gCombiningChars);
  152|      1|    unsigned int extTblLen = getTableLen(gExtenderChars);
  153|      1|    unsigned int nameTblLen = wordRangeLen + combTblLen + extTblLen;
  154|      1|    XMLInt32* nameRange = (XMLInt32*) XMLPlatformUtils::fgMemoryManager->allocate
  155|      1|    (
  156|      1|        (nameTblLen + 8) * sizeof(XMLInt32)
  157|      1|    );//new XMLInt32[nameTblLen + 8];
  158|       |
  159|      1|    tok->setRangeValues(nameRange, nameTblLen + 8);
  160|      1|    memcpy(nameRange, wordRange, wordRangeLen * sizeof(XMLInt32));
  161|      1|    setupRange(nameRange, gCombiningChars, wordRangeLen);
  162|      1|    setupRange(nameRange, gExtenderChars, wordRangeLen + combTblLen);
  163|      1|    nameRange[nameTblLen++] = chDash;
  164|      1|    nameRange[nameTblLen++] = chDash;
  165|      1|    nameRange[nameTblLen++] = chColon;
  166|      1|    nameRange[nameTblLen++] = chColon;
  167|      1|    nameRange[nameTblLen++] = chPeriod;
  168|      1|    nameRange[nameTblLen++] = chPeriod;
  169|      1|    nameRange[nameTblLen++] = chUnderscore;
  170|      1|    nameRange[nameTblLen++] = chUnderscore;
  171|      1|    tok->sortRanges();
  172|      1|    tok->compactRanges();
  173|       |    // Build the internal map.
  174|      1|    tok->createMap();
  175|      1|    rangeTokMap->setRangeToken(fgXMLNameChar, tok);
  176|       |
  177|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  178|       |    // Build the internal map.
  179|      1|    tok->createMap();
  180|      1|    rangeTokMap->setRangeToken(fgXMLNameChar, tok , true);
  181|       |
  182|       |    // Create initialNameChar ranges
  183|      1|    tok = tokFactory->createRange();
  184|      1|    unsigned int initialNameTblLen = baseTblLen + ideoTblLen;
  185|      1|    XMLInt32* initialNameRange = (XMLInt32*) XMLPlatformUtils::fgMemoryManager->allocate
  186|      1|    (
  187|      1|        (initialNameTblLen + 4) * sizeof(XMLInt32)
  188|      1|    );//new XMLInt32[initialNameTblLen + 4];
  189|       |
  190|      1|    tok->setRangeValues(initialNameRange, initialNameTblLen + 4);
  191|      1|    memcpy(initialNameRange, wordRange, initialNameTblLen * sizeof(XMLInt32));
  192|      1|    initialNameRange[initialNameTblLen++] = chColon;
  193|      1|    initialNameRange[initialNameTblLen++] = chColon;
  194|      1|    initialNameRange[initialNameTblLen++] = chUnderscore;
  195|      1|    initialNameRange[initialNameTblLen++] = chUnderscore;
  196|      1|    tok->sortRanges();
  197|      1|    tok->compactRanges();
  198|       |    // Build the internal map.
  199|      1|    tok->createMap();
  200|      1|    rangeTokMap->setRangeToken(fgXMLInitialNameChar, tok);
  201|       |
  202|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  203|       |    // Build the internal map.
  204|      1|    tok->createMap();
  205|      1|    rangeTokMap->setRangeToken(fgXMLInitialNameChar, tok , true);
  206|       |
  207|       |    // Create word range
  208|       |    // \w = [#x0000-#x10FFFF]-[\p{P}\p{Z}\p{C}] (all characters except the set of "punctuation", "separator" and "other" characters) 
  209|      1|    tok = tokFactory->createRange();
  210|  65.5k|    for(int i=0; i<=0xFFFF; i++)
  ------------------
  |  Branch (210:18): [True: 65.5k, False: 1]
  ------------------
  211|  65.5k|    {
  212|  65.5k|        unsigned short chType=UnicodeRangeFactory::getUniCategory(XMLUniCharacter::getType(i));
  213|  65.5k|        if(chType == UnicodeRangeFactory::CHAR_PUNCTUATION || 
  ------------------
  |  Branch (213:12): [True: 367, False: 65.1k]
  ------------------
  214|  65.5k|           chType == UnicodeRangeFactory::CHAR_SEPARATOR || 
  ------------------
  |  Branch (214:12): [True: 20, False: 65.1k]
  ------------------
  215|  65.5k|           chType == UnicodeRangeFactory::CHAR_OTHER)
  ------------------
  |  Branch (215:12): [True: 14.9k, False: 50.2k]
  ------------------
  216|  15.2k|            tok->addRange(i, i);
  217|  65.5k|    }
  218|      1|    tok->sortRanges();
  219|      1|    tok->compactRanges();
  220|       |    // Build the internal map.
  221|      1|    tok->createMap();
  222|      1|    rangeTokMap->setRangeToken(fgXMLWord, tok , true);
  223|       |
  224|      1|    tok = RangeToken::complementRanges(tok, tokFactory);
  225|       |    // Build the internal map.
  226|      1|    tok->createMap();
  227|      1|    rangeTokMap->setRangeToken(fgXMLWord, tok);
  228|       |
  229|       |
  230|      1|    fRangesCreated = true;
  231|      1|}
_ZN11xercesc_3_215XMLRangeFactory20initializeKeywordMapEPNS_13RangeTokenMapE:
  236|      1|void XMLRangeFactory::initializeKeywordMap(RangeTokenMap *rangeTokMap) {
  237|       |
  238|      1|    if (fKeywordsInitialized)
  ------------------
  |  Branch (238:9): [True: 0, False: 1]
  ------------------
  239|      0|        return;
  240|       |
  241|      1|    rangeTokMap->addKeywordMap(fgXMLSpace, fgXMLCategory);
  242|      1|    rangeTokMap->addKeywordMap(fgXMLDigit, fgXMLCategory);
  243|      1|    rangeTokMap->addKeywordMap(fgXMLWord, fgXMLCategory);
  244|      1|    rangeTokMap->addKeywordMap(fgXMLNameChar, fgXMLCategory);
  245|      1|    rangeTokMap->addKeywordMap(fgXMLInitialNameChar, fgXMLCategory);
  246|       |
  247|      1|    fKeywordsInitialized = true;
  248|      1|}
XMLRangeFactory.cpp:_ZN11xercesc_3_2L11getTableLenEPKDs:
   64|      6|static unsigned int getTableLen(const XMLCh* const theTable) {
   65|       |
   66|      6|    XMLSize_t rangeLen = XMLString::stringLen(theTable);
   67|       |
   68|      6|    return (unsigned int)(rangeLen + 2*XMLString::stringLen(theTable + rangeLen + 1));
   69|      6|}
XMLRangeFactory.cpp:_ZN11xercesc_3_2L10setupRangeEPiPKDsj:
   42|      6|                       unsigned int startingIndex) {
   43|       |
   44|      6|    const XMLCh* pchCur = theTable;
   45|       |
   46|       |    // Do the ranges first
   47|    478|    while (*pchCur)
  ------------------
  |  Branch (47:12): [True: 472, False: 6]
  ------------------
   48|    472|    {
   49|    472|        rangeMap[startingIndex++] = *pchCur++;
   50|    472|    }
   51|       |
   52|       |    // Skip the range terminator
   53|      6|    pchCur++;
   54|       |
   55|       |    // And then the singles until we hit its terminator
   56|    100|    while (*pchCur) {
  ------------------
  |  Branch (56:12): [True: 94, False: 6]
  ------------------
   57|       |
   58|     94|        const XMLCh chSingle = *pchCur++;
   59|     94|        rangeMap[startingIndex++] = chSingle;
   60|     94|        rangeMap[startingIndex++] = chSingle;
   61|     94|    }
   62|      6|}

_ZN11xercesc_3_215XMLUniCharacter7getTypeEDs:
   43|   131k|unsigned short XMLUniCharacter::getType(const XMLCh ch) {
   44|       |
   45|       |#if XERCES_USE_TRANSCODER_ICU
   46|       |    return (unsigned short) u_charType(ch);
   47|       |#else
   48|   131k|    return (unsigned short) fgUniCharsTable[ch];
   49|   131k|#endif
   50|   131k|}

_ZN11xercesc_3_29DTDAttDefC2EPNS_13MemoryManagerE:
   39|    277|{
   40|    277|}
_ZN11xercesc_3_29DTDAttDefC2EPKDsNS_9XMLAttDef8AttTypesENS3_11DefAttTypesEPNS_13MemoryManagerE:
   49|  9.22k|{
   50|  9.22k|    fName = XMLString::replicate(attName, getMemoryManager());
   51|  9.22k|}
_ZN11xercesc_3_29DTDAttDefD2Ev:
   68|  9.49k|{
   69|  9.49k|    getMemoryManager()->deallocate(fName); //delete [] fName;
   70|  9.49k|}
_ZN11xercesc_3_29DTDAttDef7setNameEPKDs:
   77|  5.91k|{
   78|  5.91k|    getMemoryManager()->deallocate(fName); //delete [] fName;
   79|  5.91k|    fName = XMLString::replicate(newName, getMemoryManager());
   80|  5.91k|}

_ZNK11xercesc_3_29DTDAttDef11getFullNameEv:
  117|   291k|{
  118|   291k|    return fName;
  119|   291k|}
_ZN11xercesc_3_29DTDAttDef9setElemIdEm:
  134|  9.22k|{
  135|  9.22k|    fElemId = newId;
  136|  9.22k|}

_ZN11xercesc_3_213DTDAttDefListC2EPNS_14RefHashTableOfINS_9DTDAttDefENS_12StringHasherEEEPNS_13MemoryManagerE:
   42|  39.0k|{
   43|  39.0k|    fEnum = new (getMemoryManager()) RefHashTableOfEnumerator<DTDAttDef>(listToUse, false, manager);
   44|  39.0k|    fArray = (DTDAttDef **)(manager->allocate( sizeof(DTDAttDef*) << 1));
   45|  39.0k|    fSize = 2;
   46|  39.0k|}
_ZN11xercesc_3_213DTDAttDefListD2Ev:
   49|  39.0k|{
   50|  39.0k|    delete fEnum;
   51|  39.0k|    (getMemoryManager())->deallocate(fArray);
   52|  39.0k|}
_ZNK11xercesc_3_213DTDAttDefList14getAttDefCountEv:
  102|   304k|{
  103|   304k|    return fCount;
  104|   304k|}
_ZN11xercesc_3_213DTDAttDefList9getAttDefEm:
  110|   245k|{
  111|   245k|    if(index >= fCount)
  ------------------
  |  Branch (111:8): [True: 0, False: 245k]
  ------------------
  112|      0|        ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::AttrList_BadIndex, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  113|   245k|    return *(fArray[index]);
  114|   245k|}

_ZN11xercesc_3_213DTDAttDefList9addAttDefEPNS_9DTDAttDefE:
  146|  9.22k|{
  147|  9.22k|    if(fCount == fSize)
  ------------------
  |  Branch (147:8): [True: 1.12k, False: 8.09k]
  ------------------
  148|  1.12k|    {
  149|       |        // need to grow fArray
  150|  1.12k|        fSize <<= 1;
  151|  1.12k|        DTDAttDef** newArray = (DTDAttDef **)((getMemoryManager())->allocate( sizeof(DTDAttDef*) * fSize ));
  152|  1.12k|        memcpy(newArray, fArray, fCount * sizeof(DTDAttDef *));
  153|  1.12k|        (getMemoryManager())->deallocate(fArray);
  154|  1.12k|        fArray = newArray;
  155|  1.12k|    }
  156|  9.22k|    fArray[fCount++] = toAdd;
  157|  9.22k|}

_ZN11xercesc_3_214DTDElementDeclC2EPKDsjNS0_10ModelTypesEPNS_13MemoryManagerE:
   67|  52.7k|{
   68|  52.7k|    setElementName(elemRawName, uriId);
   69|  52.7k|}
_ZN11xercesc_3_214DTDElementDeclD2Ev:
   86|  52.7k|{
   87|  52.7k|    delete fAttDefs;
   88|  52.7k|    delete fAttList;
   89|  52.7k|    delete fContentSpec;
   90|  52.7k|    delete fContentModel;
   91|  52.7k|    getMemoryManager()->deallocate(fFormattedModel);//delete [] fFormattedModel;
   92|  52.7k|}
_ZNK11xercesc_3_214DTDElementDecl13getAttDefListEv:
  100|  59.5k|{
  101|  59.5k|    if (!fAttList)
  ------------------
  |  Branch (101:9): [True: 37.5k, False: 21.9k]
  ------------------
  102|  37.5k|    {
  103|       |        // If the att def list is not made yet, then fault it in too
  104|  37.5k|        if (!fAttDefs)
  ------------------
  |  Branch (104:13): [True: 37.5k, False: 0]
  ------------------
  105|  37.5k|            faultInAttDefList();
  106|       |
  107|  37.5k|        ((DTDElementDecl*)this)->fAttList = new (getMemoryManager()) DTDAttDefList(fAttDefs,getMemoryManager());
  108|  37.5k|    }
  109|       |
  110|  59.5k|    return *fAttList;
  111|  59.5k|}
_ZNK11xercesc_3_214DTDElementDecl15getCharDataOptsEv:
  115|   819k|{
  116|   819k|    XMLElementDecl::CharDataOpts retVal;
  117|   819k|    switch(fModelType)
  118|   819k|    {
  119|  29.0k|        case Children :
  ------------------
  |  Branch (119:9): [True: 29.0k, False: 790k]
  ------------------
  120|  29.0k|            retVal = XMLElementDecl::SpacesOk;
  121|  29.0k|            break;
  122|       |
  123|  4.95k|        case Empty :
  ------------------
  |  Branch (123:9): [True: 4.95k, False: 814k]
  ------------------
  124|  4.95k|            retVal = XMLElementDecl::NoCharData;
  125|  4.95k|            break;
  126|       |
  127|   785k|        default :
  ------------------
  |  Branch (127:9): [True: 785k, False: 34.0k]
  ------------------
  128|   785k|            retVal = XMLElementDecl::AllCharData;
  129|   785k|            break;
  130|   819k|    }
  131|   819k|    return retVal;
  132|   819k|}
_ZNK11xercesc_3_214DTDElementDecl10hasAttDefsEv:
  136|   558k|{
  137|       |    // If the collection hasn't been faulted in, then no att defs
  138|   558k|    if (!fAttDefs)
  ------------------
  |  Branch (138:9): [True: 438k, False: 119k]
  ------------------
  139|   438k|        return false;
  140|       |
  141|   119k|    return !fAttDefs->isEmpty();
  142|   558k|}
_ZN11xercesc_3_214DTDElementDecl14setContentSpecEPNS_15ContentSpecNodeE:
  146|  3.12k|{
  147|  3.12k|    delete fContentSpec;
  148|  3.12k|    fContentSpec = toAdopt;
  149|       |
  150|       |    //reset Content Model
  151|  3.12k|    setContentModel(0);
  152|       |
  153|  3.12k|}
_ZNK11xercesc_3_214DTDElementDecl24getFormattedContentModelEv:
  157|  16.1k|{
  158|       |    //
  159|       |    //  If its not already built, then call the protected virtual method
  160|       |    //  to allow the derived class to build it (since only it knows.)
  161|       |    //  Otherwise, just return the previously formatted methods.
  162|       |    //
  163|       |    //  Since we are faulting this in, within a const getter, we have to
  164|       |    //  cast off the const-ness.
  165|       |    //
  166|  16.1k|    if (!fFormattedModel)
  ------------------
  |  Branch (166:9): [True: 1.38k, False: 14.7k]
  ------------------
  167|  1.38k|        ((DTDElementDecl*)this)->fFormattedModel = formatContentModel();
  168|       |
  169|  16.1k|    return fFormattedModel;
  170|  16.1k|}
_ZN11xercesc_3_214DTDElementDecl9getAttDefEPKDs:
  187|   488k|{
  188|       |    // If no list, then return a null
  189|   488k|    if (!fAttDefs)
  ------------------
  |  Branch (189:9): [True: 382k, False: 105k]
  ------------------
  190|   382k|        return 0;
  191|       |
  192|   105k|    return fAttDefs->get(attName);
  193|   488k|}
_ZN11xercesc_3_214DTDElementDecl9addAttDefEPNS_9DTDAttDefE:
  200|  9.22k|{
  201|       |    // Fault in the att list if required
  202|  9.22k|    if (!fAttDefs)
  ------------------
  |  Branch (202:9): [True: 1.44k, False: 7.77k]
  ------------------
  203|  1.44k|            faultInAttDefList();
  204|       |
  205|       |    // Tell this guy the element id of its parent (us)
  206|  9.22k|    toAdd->setElemId(getId());
  207|       |
  208|  9.22k|    fAttDefs->put((void*)(toAdd->getFullName()), toAdd);
  209|       |    // update and/or create fAttList
  210|  9.22k|    if(!fAttList)
  ------------------
  |  Branch (210:8): [True: 1.44k, False: 7.77k]
  ------------------
  211|  1.44k|        ((DTDElementDecl*)this)->fAttList = new (getMemoryManager()) DTDAttDefList(fAttDefs,getMemoryManager());
  212|  9.22k|    fAttList->addAttDef(toAdd);
  213|  9.22k|}
_ZNK11xercesc_3_214DTDElementDecl18formatContentModelEv:
  220|  1.38k|{
  221|  1.38k|    XMLCh* newValue = 0;
  222|  1.38k|    if (fModelType == Any)
  ------------------
  |  Branch (222:9): [True: 0, False: 1.38k]
  ------------------
  223|      0|    {
  224|      0|        newValue = XMLString::replicate(XMLUni::fgAnyString, getMemoryManager());
  225|      0|    }
  226|  1.38k|     else if (fModelType == Empty)
  ------------------
  |  Branch (226:15): [True: 37, False: 1.35k]
  ------------------
  227|     37|    {
  228|     37|        newValue = XMLString::replicate(XMLUni::fgEmptyString, getMemoryManager());
  229|     37|    }
  230|  1.35k|     else
  231|  1.35k|    {
  232|       |        //
  233|       |        //  Use a temp XML buffer to format into. Content models could be
  234|       |        //  pretty long, but very few will be longer than one K. The buffer
  235|       |        //  will expand to handle the more pathological ones.
  236|       |        //
  237|  1.35k|        XMLBuffer bufFmt(1023, getMemoryManager());
  238|  1.35k|        getContentSpec()->formatSpec(bufFmt);
  239|  1.35k|        newValue = XMLString::replicate(bufFmt.getRawBuffer(), getMemoryManager());
  240|  1.35k|    }
  241|  1.38k|    return newValue;
  242|  1.38k|}
_ZN11xercesc_3_214DTDElementDecl16makeContentModelEv:
  245|  1.59k|{
  246|  1.59k|    XMLContentModel* cmRet = 0;
  247|  1.59k|    if (fModelType == Mixed_Simple)
  ------------------
  |  Branch (247:9): [True: 108, False: 1.48k]
  ------------------
  248|    108|    {
  249|       |        //
  250|       |        //  Just create a mixel content model object. This type of
  251|       |        //  content model is optimized for mixed content validation.
  252|       |        //
  253|    108|        cmRet = new (getMemoryManager()) MixedContentModel(true, this->getContentSpec(), false, getMemoryManager());
  254|    108|    }
  255|  1.48k|     else if (fModelType == Children)
  ------------------
  |  Branch (255:15): [True: 1.48k, False: 0]
  ------------------
  256|  1.48k|    {
  257|       |        //
  258|       |        //  This method will create an optimal model for the complexity
  259|       |        //  of the element's defined model. If its simple, it will create
  260|       |        //  a SimpleContentModel object. If its a simple list, it will
  261|       |        //  create a SimpleListContentModel object. If its complex, it
  262|       |        //  will create a DFAContentModel object.
  263|       |        //
  264|  1.48k|        cmRet = createChildModel();
  265|  1.48k|    }
  266|      0|     else
  267|      0|    {
  268|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_MustBeMixedOrChildren, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  269|      0|    }
  270|  1.59k|    return cmRet;
  271|  1.59k|}
_ZN11xercesc_3_214DTDElementDecl16createChildModelEv:
  275|  1.48k|{
  276|       |    // Get the content spec node of the element
  277|  1.48k|    ContentSpecNode* specNode = getContentSpec();
  278|       |
  279|  1.48k|    if(!specNode)
  ------------------
  |  Branch (279:8): [True: 0, False: 1.48k]
  ------------------
  280|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  281|       |
  282|       |    //
  283|       |    //  Do a sanity check that the node does not have a PCDATA id. Since,
  284|       |    //  if it was, it should have already gotten taken by the Mixed model.
  285|       |    //
  286|  1.48k|    if (specNode->getElement()) {
  ------------------
  |  Branch (286:9): [True: 105, False: 1.38k]
  ------------------
  287|    105|        if (specNode->getElement()->getURI() == XMLElementDecl::fgPCDataElemId)
  ------------------
  |  Branch (287:13): [True: 0, False: 105]
  ------------------
  288|      0|            ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_NoPCDATAHere, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  289|    105|    }
  290|       |
  291|       |    //
  292|       |    //  According to the type of node, we will create the correct type of
  293|       |    //  content model.
  294|       |    //
  295|  1.48k|    if (specNode->getType() == ContentSpecNode::Leaf)
  ------------------
  |  Branch (295:9): [True: 105, False: 1.38k]
  ------------------
  296|    105|    {
  297|       |        // Create a simple content model
  298|    105|        return new (getMemoryManager()) SimpleContentModel
  299|    105|        (
  300|    105|            true
  301|    105|            , specNode->getElement()
  302|    105|            , 0
  303|    105|            , ContentSpecNode::Leaf
  304|    105|            , getMemoryManager()
  305|    105|        );
  306|    105|    }
  307|  1.38k|     else if ((specNode->getType() == ContentSpecNode::Choice)
  ------------------
  |  Branch (307:15): [True: 516, False: 864]
  ------------------
  308|  1.38k|          ||  (specNode->getType() == ContentSpecNode::Sequence))
  ------------------
  |  Branch (308:15): [True: 290, False: 574]
  ------------------
  309|    806|    {
  310|       |        //
  311|       |        //  Lets see if both of the children are leafs. If so, then it has to
  312|       |        //  be a simple content model
  313|       |        //
  314|    806|        if ((specNode->getFirst()->getType() == ContentSpecNode::Leaf)
  ------------------
  |  Branch (314:13): [True: 650, False: 156]
  ------------------
  315|    806|        &&  (specNode->getSecond()->getType() == ContentSpecNode::Leaf))
  ------------------
  |  Branch (315:13): [True: 149, False: 501]
  ------------------
  316|    149|        {
  317|    149|            return new (getMemoryManager()) SimpleContentModel
  318|    149|            (
  319|    149|                true
  320|    149|                , specNode->getFirst()->getElement()
  321|    149|                , specNode->getSecond()->getElement()
  322|    149|                , specNode->getType()
  323|    149|                , getMemoryManager()
  324|    149|            );
  325|    149|        }
  326|    806|    }
  327|    574|     else if ((specNode->getType() == ContentSpecNode::OneOrMore)
  ------------------
  |  Branch (327:15): [True: 436, False: 138]
  ------------------
  328|    574|          ||  (specNode->getType() == ContentSpecNode::ZeroOrMore)
  ------------------
  |  Branch (328:15): [True: 55, False: 83]
  ------------------
  329|    574|          ||  (specNode->getType() == ContentSpecNode::ZeroOrOne))
  ------------------
  |  Branch (329:15): [True: 83, False: 0]
  ------------------
  330|    574|    {
  331|       |        //
  332|       |        //  Its a repetition, so see if its one child is a leaf. If so its a
  333|       |        //  repetition of a single element, so we can do a simple content
  334|       |        //  model for that.
  335|       |        //
  336|    574|        if (specNode->getFirst()->getType() == ContentSpecNode::Leaf)
  ------------------
  |  Branch (336:13): [True: 134, False: 440]
  ------------------
  337|    134|        {
  338|    134|            return new (getMemoryManager()) SimpleContentModel
  339|    134|            (
  340|    134|                true
  341|    134|                , specNode->getFirst()->getElement()
  342|    134|                , 0
  343|    134|                , specNode->getType()
  344|    134|                , getMemoryManager()
  345|    134|            );
  346|    134|        }
  347|    574|    }
  348|      0|     else
  349|      0|    {
  350|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  351|      0|    }
  352|       |
  353|       |    // Its not any simple type of content, so create a DFA based content model
  354|  1.09k|    return new (getMemoryManager()) DFAContentModel
  355|  1.09k|    (
  356|  1.09k|        true
  357|  1.09k|        , this->getContentSpec()
  358|  1.09k|        , getMemoryManager()
  359|  1.09k|    );
  360|  1.48k|}
_ZNK11xercesc_3_214DTDElementDecl17faultInAttDefListEv:
  364|  39.0k|{
  365|       |    // Use a hash modulus of 29 and tell it owns its elements
  366|  39.0k|    ((DTDElementDecl*)this)->fAttDefs = new (getMemoryManager()) RefHashTableOf<DTDAttDef>(29, true, getMemoryManager());
  367|  39.0k|}

_ZN11xercesc_3_214DTDElementDecl14getContentSpecEv:
  190|  2.69k|{
  191|  2.69k|    return fContentSpec;
  192|  2.69k|}
_ZNK11xercesc_3_214DTDElementDecl14getContentSpecEv:
  195|  1.35k|{
  196|  1.35k|    return fContentSpec;
  197|  1.35k|}
_ZN11xercesc_3_214DTDElementDecl15getContentModelEv:
  200|  21.3k|{
  201|  21.3k|    if (!fContentModel)
  ------------------
  |  Branch (201:9): [True: 1.59k, False: 19.7k]
  ------------------
  202|  1.59k|        fContentModel = makeContentModel();
  203|  21.3k|    return fContentModel;
  204|  21.3k|}
_ZN11xercesc_3_214DTDElementDecl15setContentModelEPNS_15XMLContentModelE:
  208|  3.12k|{
  209|  3.12k|    delete fContentModel;
  210|  3.12k|    fContentModel = newModelToAdopt;
  211|       |
  212|       |    // reset formattedModel
  213|  3.12k|    if (fFormattedModel)
  ------------------
  |  Branch (213:9): [True: 0, False: 3.12k]
  ------------------
  214|      0|    {
  215|      0|        getMemoryManager()->deallocate(fFormattedModel);
  216|      0|        fFormattedModel = 0;
  217|      0|    }
  218|  3.12k|}
_ZNK11xercesc_3_214DTDElementDecl6getKeyEv:
  224|   105k|{
  225|   105k|    return getFullName();
  226|   105k|}
_ZNK11xercesc_3_214DTDElementDecl12getModelTypeEv:
  232|   311k|{
  233|   311k|    return fModelType;
  234|   311k|}
_ZN11xercesc_3_214DTDElementDecl12setModelTypeENS0_10ModelTypesE:
  241|  4.55k|{
  242|  4.55k|    fModelType = toSet;
  243|  4.55k|}

_ZNK11xercesc_3_213DTDEntityDecl22getDeclaredInIntSubsetEv:
  169|  9.90k|{
  170|  9.90k|    return fDeclaredInIntSubset;
  171|  9.90k|}
_ZNK11xercesc_3_213DTDEntityDecl16getIsSpecialCharEv:
  179|  16.9k|{
  180|  16.9k|    return fIsSpecialChar;
  181|  16.9k|}
_ZN11xercesc_3_213DTDEntityDecl22setDeclaredInIntSubsetEb:
  188|  2.88k|{
  189|  2.88k|    fDeclaredInIntSubset = newValue;
  190|  2.88k|}
_ZN11xercesc_3_213DTDEntityDecl14setIsParameterEb:
  193|  7.22k|{
  194|  7.22k|    fIsParameter = newValue;
  195|  7.22k|}
_ZN11xercesc_3_213DTDEntityDeclC2EPKDsDsbb:
  157|      5|{
  158|      5|}
_ZN11xercesc_3_213DTDEntityDeclC2EPNS_13MemoryManagerE:
  124|    259|{
  125|    259|}
_ZN11xercesc_3_213DTDEntityDeclC2EPKDsbPNS_13MemoryManagerE:
  135|  2.88k|{
  136|  2.88k|}

_ZN11xercesc_3_214XMLInitializer20initializeDTDGrammarEv:
   42|      1|{
   43|      1|    DTDGrammar::fDefaultEntities = new NameIdPool<DTDEntityDecl>(11, 12);
   44|       |
   45|       |    // Add the default entity entries for the character refs that must
   46|       |    // always be present. We indicate that they are from the internal
   47|       |    // subset. They aren't really, but they have to look that way so
   48|       |    // that they are still valid for use within a standalone document.
   49|       |    //
   50|       |    // We also mark them as special char entities, which allows them
   51|       |    // to be used in places whether other non-numeric general entities
   52|       |    // cannot.
   53|       |    //
   54|      1|    if (DTDGrammar::fDefaultEntities)
  ------------------
  |  Branch (54:9): [True: 1, False: 0]
  ------------------
   55|      1|    {
   56|      1|        DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgAmp, chAmpersand, true, true));
   57|      1|        DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgLT, chOpenAngle, true, true));
   58|      1|        DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgGT, chCloseAngle, true, true));
   59|      1|        DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgQuot, chDoubleQuote, true, true));
   60|      1|        DTDGrammar::fDefaultEntities->put(new DTDEntityDecl(XMLUni::fgApos, chSingleQuote, true, true));
   61|      1|    }
   62|      1|}
_ZN11xercesc_3_210DTDGrammarC2EPNS_13MemoryManagerE:
   81|  8.51k|{
   82|       |    //
   83|       |    //  Init all the pool members.
   84|       |    //
   85|       |    //  <TBD> Investigate what the optimum values would be for the various
   86|       |    //  pools.
   87|       |    //
   88|  8.51k|    fElemDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(109, 128, fMemoryManager);
   89|       |    // should not need this in the common situation where grammars
   90|       |    // are built once and then read - NG
   91|       |    //fElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
   92|  8.51k|    fEntityDeclPool = new (fMemoryManager) NameIdPool<DTDEntityDecl>(109, 128, fMemoryManager);
   93|  8.51k|    fNotationDeclPool = new (fMemoryManager) NameIdPool<XMLNotationDecl>(109, 128, fMemoryManager);
   94|       |
   95|       |    //REVISIT: use grammarPool to create
   96|  8.51k|    fGramDesc = new (fMemoryManager) XMLDTDDescriptionImpl(XMLUni::fgDTDEntityString, fMemoryManager);
   97|  8.51k|}
_ZN11xercesc_3_210DTDGrammarD2Ev:
  100|  8.51k|{
  101|  8.51k|    delete fElemDeclPool;
  102|  8.51k|    if(fElemNonDeclPool)
  ------------------
  |  Branch (102:8): [True: 0, False: 8.51k]
  ------------------
  103|      0|    {
  104|      0|        delete fElemNonDeclPool;
  105|      0|    }
  106|  8.51k|    delete fEntityDeclPool;
  107|  8.51k|    delete fNotationDeclPool;
  108|  8.51k|    delete fGramDesc;
  109|  8.51k|}
_ZNK11xercesc_3_210DTDGrammar21getGrammarDescriptionEv:
  201|  8.51k|{
  202|  8.51k|    return fGramDesc;
  203|  8.51k|}

_ZNK11xercesc_3_210DTDGrammar14getGrammarTypeEv:
  287|   844k|inline Grammar::GrammarType DTDGrammar::getGrammarType() const {
  288|   844k|    return Grammar::DTDGrammarType;
  289|   844k|}
_ZNK11xercesc_3_210DTDGrammar12getValidatedEv:
  380|  4.22k|{
  381|  4.22k|    return fValidated;
  382|  4.22k|}
_ZN11xercesc_3_210DTDGrammar11getElemDeclEjPKDsS2_j:
  328|  2.07M|{
  329|  2.07M|    XMLElementDecl* elemDecl = fElemDeclPool->getByKey(qName);
  330|       |
  331|  2.07M|    if (!elemDecl && fElemNonDeclPool)
  ------------------
  |  Branch (331:9): [True: 477k, False: 1.59M]
  |  Branch (331:22): [True: 0, False: 477k]
  ------------------
  332|      0|        elemDecl = fElemNonDeclPool->getByKey(qName);
  333|       |
  334|  2.07M|    return elemDecl;
  335|  2.07M|}
_ZN11xercesc_3_210DTDGrammar15getNotationDeclEPKDs:
  370|  3.04k|{
  371|  3.04k|    return fNotationDeclPool->getByKey(notName);
  372|  3.04k|}
_ZN11xercesc_3_210DTDGrammar11putElemDeclEPNS_14XMLElementDeclEb:
  352|  46.9k|{
  353|  46.9k|    if (notDeclared)
  ------------------
  |  Branch (353:9): [True: 0, False: 46.9k]
  ------------------
  354|      0|    {
  355|      0|        if(!fElemNonDeclPool)
  ------------------
  |  Branch (355:12): [True: 0, False: 0]
  ------------------
  356|      0|            fElemNonDeclPool = new (fMemoryManager) NameIdPool<DTDElementDecl>(29, 128, fMemoryManager);
  357|      0|        return fElemNonDeclPool->put((DTDElementDecl*) elemDecl);
  358|      0|    }
  359|       |
  360|  46.9k|    return fElemDeclPool->put((DTDElementDecl*) elemDecl);
  361|  46.9k|}
_ZNK11xercesc_3_210DTDGrammar15putNotationDeclEPNS_15XMLNotationDeclE:
  375|  1.86k|{
  376|  1.86k|    return fNotationDeclPool->put(notationDecl);
  377|  1.86k|}
_ZN11xercesc_3_210DTDGrammar12setValidatedEb:
  385|  4.22k|{
  386|  4.22k|    fValidated = newState;
  387|  4.22k|}
_ZNK11xercesc_3_210DTDGrammar17getElemEnumeratorEv:
  227|  4.22k|{
  228|  4.22k|    return NameIdPoolEnumerator<DTDElementDecl>(fElemDeclPool, fMemoryManager);
  229|  4.22k|}
_ZNK11xercesc_3_210DTDGrammar19getEntityEnumeratorEv:
  233|  4.22k|{
  234|  4.22k|    return NameIdPoolEnumerator<DTDEntityDecl>(fEntityDeclPool, fMemoryManager);
  235|  4.22k|}
_ZN11xercesc_3_210DTDGrammar13getEntityDeclEPKDs:
  255|  36.7k|{
  256|  36.7k|    DTDEntityDecl* decl = fDefaultEntities->getByKey(entName);
  257|       |
  258|  36.7k|    if (!decl)
  ------------------
  |  Branch (258:9): [True: 35.9k, False: 854]
  ------------------
  259|  35.9k|        return fEntityDeclPool->getByKey(entName);
  260|       |
  261|    854|    return decl;
  262|  36.7k|}
_ZNK11xercesc_3_210DTDGrammar13putEntityDeclEPNS_13DTDEntityDeclE:
  279|  2.53k|{
  280|  2.53k|    return fEntityDeclPool->put(entityDecl);
  281|  2.53k|}

_ZN11xercesc_3_210DTDScannerC2EPNS_10DTDGrammarEPNS_14DocTypeHandlerEPNS_13MemoryManagerES6_:
  124|  8.30k|{
  125|  8.30k|    fPEntityDeclPool = new (fMemoryManager) NameIdPool<DTDEntityDecl>(109, 128, fMemoryManager);
  126|  8.30k|}
_ZN11xercesc_3_210DTDScannerD2Ev:
  129|  8.30k|{
  130|  8.30k|    delete fDumAttDef;
  131|  8.30k|    delete fDumElemDecl;
  132|  8.30k|    delete fDumEntityDecl;
  133|  8.30k|    delete fPEntityDeclPool;
  134|  8.30k|}
_ZN11xercesc_3_210DTDScanner14setScannerInfoEPNS_10XMLScannerEPNS_9ReaderMgrEPNS_12XMLBufferMgrE:
  142|  8.30k|{
  143|       |    // We don't own any of these, we just reference them
  144|  8.30k|    fScanner = owningScanner;
  145|  8.30k|    fReaderMgr = readerMgr;
  146|  8.30k|    fBufMgr = bufMgr;
  147|       |
  148|  8.30k|    if (fScanner->getDoNamespaces())
  ------------------
  |  Branch (148:9): [True: 0, False: 8.30k]
  ------------------
  149|      0|        fEmptyNamespaceId = fScanner->getEmptyNamespaceId();
  150|  8.30k|    else
  151|  8.30k|        fEmptyNamespaceId = 0;
  152|       |
  153|  8.30k|    fDocTypeReaderId = fReaderMgr->getCurrentReaderNum();
  154|  8.30k|}
_ZN11xercesc_3_210DTDScanner13checkForPERefEbb:
  162|  1.69M|{
  163|  1.69M|    bool gotSpace = false;
  164|       |
  165|       |    //
  166|       |    //  See if we have any spaces up front. If so, then skip them and set
  167|       |    //  the gotSpaces flag.
  168|       |    //
  169|  1.69M|    if (fReaderMgr->skippedSpace())
  ------------------
  |  Branch (169:9): [True: 90.5k, False: 1.60M]
  ------------------
  170|  90.5k|    {
  171|  90.5k|        fReaderMgr->skipPastSpaces();
  172|  90.5k|        gotSpace = true;
  173|  90.5k|    }
  174|       |
  175|       |    // If the next char is a percent, then expand the PERef
  176|  1.69M|    if (!fReaderMgr->skippedChar(chPercent))
  ------------------
  |  Branch (176:9): [True: 1.69M, False: 58]
  ------------------
  177|  1.69M|       return gotSpace;
  178|       |
  179|     70|    while (true)
  ------------------
  |  Branch (179:12): [Folded - Ignored]
  ------------------
  180|     12|    {
  181|     12|       if (!expandPERef(false, inLiteral, inMarkup, false))
  ------------------
  |  Branch (181:12): [True: 0, False: 12]
  ------------------
  182|      0|          fScanner->emitError(XMLErrs::ExpectedEntityRefName);
  183|       |       // And skip any more spaces in the expanded value
  184|     12|       if (fReaderMgr->skippedSpace())
  ------------------
  |  Branch (184:12): [True: 0, False: 12]
  ------------------
  185|      0|       {
  186|      0|          fReaderMgr->skipPastSpaces();
  187|      0|          gotSpace = true;
  188|      0|       }
  189|     12|       if (!fReaderMgr->skippedChar(chPercent))
  ------------------
  |  Branch (189:12): [True: 0, False: 12]
  ------------------
  190|      0|          break;
  191|     12|    }
  192|     58|    return gotSpace;
  193|  1.69M|}
_ZN11xercesc_3_210DTDScanner11expandPERefEbbbb:
  200|  2.13k|{
  201|  2.13k|    fScanner->setHasNoDTD(false);
  202|  2.13k|    XMLBufBid bbName(fBufMgr);
  203|       |
  204|       |    //
  205|       |    //  If we are in the internal subset and in markup, then this is
  206|       |    //  an error but we go ahead and do it anyway.
  207|       |    //
  208|  2.13k|    if (fInternalSubset && inMarkup)
  ------------------
  |  Branch (208:9): [True: 2.13k, False: 0]
  |  Branch (208:28): [True: 19, False: 2.11k]
  ------------------
  209|     19|        fScanner->emitError(XMLErrs::PERefInMarkupInIntSubset);
  210|       |
  211|  2.13k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (211:9): [True: 6, False: 2.12k]
  ------------------
  212|      6|    {
  213|      6|        fScanner->emitError(XMLErrs::ExpectedPEName);
  214|       |
  215|       |        // Skip the semicolon if that's what we ended up on
  216|      6|        fReaderMgr->skippedChar(chSemiColon);
  217|      6|        return false;
  218|      6|    }
  219|       |
  220|       |    // If no terminating semicolon, emit an error but try to keep going
  221|  2.12k|    if (!fReaderMgr->skippedChar(chSemiColon))
  ------------------
  |  Branch (221:9): [True: 13, False: 2.11k]
  ------------------
  222|     13|        fScanner->emitError(XMLErrs::UnterminatedEntityRef, bbName.getRawBuffer());
  223|       |
  224|       |    //
  225|       |    //  Look it up in the PE decl pool and see if it exists. If not, just
  226|       |    //  emit an error and continue.
  227|       |    //
  228|  2.12k|    XMLEntityDecl* decl = fPEntityDeclPool->getByKey(bbName.getRawBuffer());
  229|  2.12k|    if (!decl)
  ------------------
  |  Branch (229:9): [True: 1.33k, False: 792]
  ------------------
  230|  1.33k|    {
  231|       |        // XML 1.0 Section 4.1
  232|  1.33k|        if (fScanner->getStandalone()) {
  ------------------
  |  Branch (232:13): [True: 16, False: 1.31k]
  ------------------
  233|       |            // no need to check fScanner->fHasNoDTD which is for sure false
  234|       |            // since we are in expandPERef already
  235|     16|            fScanner->emitError(XMLErrs::EntityNotFound, bbName.getRawBuffer());
  236|     16|        }
  237|  1.31k|        else {
  238|  1.31k|            if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (238:17): [True: 0, False: 1.31k]
  ------------------
  239|      0|                fScanner->getValidator()->emitError(XMLValid::VC_EntityNotFound, bbName.getRawBuffer());
  240|  1.31k|        }
  241|       |
  242|  1.33k|        return false;
  243|  1.33k|    }
  244|       |
  245|       |    //
  246|       |    // XML 1.0 Section 2.9
  247|       |    //  If we are a standalone document, then it has to have been declared
  248|       |    //  in the internal subset. Keep going though.
  249|       |    //
  250|    792|    if (fScanner->getValidationScheme() == XMLScanner::Val_Always && fScanner->getStandalone() && !decl->getDeclaredInIntSubset())
  ------------------
  |  Branch (250:9): [True: 0, False: 792]
  |  Branch (250:70): [True: 0, False: 0]
  |  Branch (250:99): [True: 0, False: 0]
  ------------------
  251|      0|        fScanner->getValidator()->emitError(XMLValid::VC_IllegalRefInStandalone, bbName.getRawBuffer());
  252|       |
  253|       |    //
  254|       |    //  Okee dokee, we found it. So create either a memory stream with
  255|       |    //  the entity value contents, or a file stream if its an external
  256|       |    //  entity.
  257|       |    //
  258|    792|    if (decl->isExternal())
  ------------------
  |  Branch (258:9): [True: 1, False: 791]
  ------------------
  259|      1|    {
  260|       |        // And now create a reader to read this entity
  261|      1|        InputSource* srcUsed;
  262|      1|        XMLReader* reader = fReaderMgr->createReader
  263|      1|        (
  264|      1|            decl->getBaseURI()
  265|      1|            , decl->getSystemId()
  266|      1|            , decl->getPublicId()
  267|      1|            , false
  268|      1|            , inLiteral ? XMLReader::RefFrom_Literal : XMLReader::RefFrom_NonLiteral
  ------------------
  |  Branch (268:15): [True: 0, False: 1]
  ------------------
  269|      1|            , XMLReader::Type_PE
  270|      1|            , XMLReader::Source_External
  271|      1|            , srcUsed
  272|      1|            , fScanner->getCalculateSrcOfs()
  273|      1|            , fScanner->getLowWaterMark()
  274|      1|            , fScanner->getDisableDefaultEntityResolution()
  275|      1|        );
  276|       |
  277|       |        // Put a janitor on the source so its cleaned up on exit
  278|      1|        Janitor<InputSource> janSrc(srcUsed);
  279|       |
  280|       |        // If the creation failed then throw an exception
  281|      1|        if (!reader)
  ------------------
  |  Branch (281:13): [True: 1, False: 0]
  ------------------
  282|      1|            ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Gen_CouldNotOpenExtEntity, srcUsed ? srcUsed->getSystemId() : decl->getSystemId(), fMemoryManager);
  ------------------
  |  |  266|      2|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |  |  Branch (266:87): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  283|       |
  284|       |        // Set the 'throw at end' flag, to the one we were given
  285|      0|        reader->setThrowAtEnd(throwEndOfExt);
  286|       |
  287|       |        //
  288|       |        //  Push the reader. If its a recursive expansion, then emit an error
  289|       |        //  and return an failure.
  290|       |        //
  291|      0|        if (!fReaderMgr->pushReader(reader, decl))
  ------------------
  |  Branch (291:13): [True: 0, False: 0]
  ------------------
  292|      0|        {
  293|      0|            fScanner->emitError(XMLErrs::RecursiveEntity, decl->getName());
  294|      0|            return false;
  295|      0|        }
  296|       |
  297|       |        //
  298|       |        //  If the caller wants us to scan the external entity, then lets
  299|       |        //  do that now.
  300|       |        //
  301|      0|        if (scanExternal)
  ------------------
  |  Branch (301:13): [True: 0, False: 0]
  ------------------
  302|      0|        {
  303|      0|            XMLEntityHandler* entHandler = fScanner->getEntityHandler();
  304|       |
  305|       |            // If we have an entity handler, tell it we are starting this entity
  306|      0|            if (entHandler)
  ------------------
  |  Branch (306:17): [True: 0, False: 0]
  ------------------
  307|      0|                entHandler->startInputSource(*srcUsed);
  308|       |
  309|       |            //
  310|       |            //  Scan the external entity now. The parameter tells it that
  311|       |            //  it is not in an include section. Get the current reader
  312|       |            //  level so we can catch partial markup errors and be sure
  313|       |            //  to get back to here if we get an exception out of the
  314|       |            //  ext subset scan.
  315|       |            //
  316|      0|            const XMLSize_t readerNum = fReaderMgr->getCurrentReaderNum();
  317|      0|            try
  318|      0|            {
  319|      0|                scanExtSubsetDecl(false, false);
  320|      0|            }
  321|      0|            catch(const OutOfMemoryException&)
  322|      0|            {
  323|      0|                throw;
  324|      0|            }
  325|      0|            catch(...)
  326|      0|            {
  327|       |                // Pop the reader back to the original level
  328|      0|                fReaderMgr->cleanStackBackTo(readerNum);
  329|       |
  330|       |                // End the input source, even though its not happy
  331|      0|                if (entHandler)
  ------------------
  |  Branch (331:21): [True: 0, False: 0]
  ------------------
  332|      0|                    entHandler->endInputSource(*srcUsed);
  333|      0|                throw;
  334|      0|            }
  335|       |
  336|       |            // If we have an entity handler, tell it we are ending this entity
  337|      0|            if (entHandler)
  ------------------
  |  Branch (337:17): [True: 0, False: 0]
  ------------------
  338|      0|                entHandler->endInputSource(*srcUsed);
  339|      0|        }
  340|      0|        else {
  341|       |            // If it starts with the XML string, then parse a text decl
  342|      0|            if (fScanner->checkXMLDecl(true))
  ------------------
  |  Branch (342:17): [True: 0, False: 0]
  ------------------
  343|      0|                scanTextDecl();
  344|      0|        }
  345|      0|    }
  346|    791|     else
  347|    791|    {
  348|       |        // Create a reader over a memory stream over the entity value
  349|    791|        XMLReader* valueReader = fReaderMgr->createIntEntReader
  350|    791|        (
  351|    791|            decl->getName()
  352|    791|            , inLiteral ? XMLReader::RefFrom_Literal : XMLReader::RefFrom_NonLiteral
  ------------------
  |  Branch (352:15): [True: 0, False: 791]
  ------------------
  353|    791|            , XMLReader::Type_PE
  354|    791|            , decl->getValue()
  355|    791|            , decl->getValueLen()
  356|    791|            , false
  357|    791|        );
  358|       |
  359|       |        //
  360|       |        //  Trt to push the entity reader onto the reader manager stack,
  361|       |        //  where it will become the subsequent input. If it fails, that
  362|       |        //  means the entity is recursive, so issue an error. The reader
  363|       |        //  will have just been discarded, but we just keep going.
  364|       |        //
  365|    791|        if (!fReaderMgr->pushReader(valueReader, decl))
  ------------------
  |  Branch (365:13): [True: 0, False: 791]
  ------------------
  366|      0|            fScanner->emitError(XMLErrs::RecursiveEntity, decl->getName());
  367|    791|    }
  368|       |
  369|    791|    return true;
  370|    792|}
_ZN11xercesc_3_210DTDScanner10scanAttDefERNS_14DTDElementDeclERNS_9XMLBufferE:
  404|  15.1k|{
  405|       |    // Check for PE ref or optional whitespace
  406|  15.1k|    checkForPERef(false, true);
  407|       |
  408|       |    // Get the name of the attribute
  409|  15.1k|    if (!fReaderMgr->getName(bufToUse))
  ------------------
  |  Branch (409:9): [True: 10, False: 15.1k]
  ------------------
  410|     10|    {
  411|     10|        fScanner->emitError(XMLErrs::ExpectedAttrName);
  412|     10|        return 0;
  413|     10|    }
  414|       |
  415|       |    //
  416|       |    //  Look up this attribute in the parent element's attribute list. If
  417|       |    //  it already exists, then use the dummy.
  418|       |    //
  419|  15.1k|    DTDAttDef* decl = parentElem.getAttDef(bufToUse.getRawBuffer());
  420|  15.1k|    if (decl)
  ------------------
  |  Branch (420:9): [True: 5.91k, False: 9.22k]
  ------------------
  421|  5.91k|    {
  422|       |        // It already exists, so put out a warning
  423|  5.91k|        fScanner->emitError
  424|  5.91k|        (
  425|  5.91k|            XMLErrs::AttListAlreadyExists
  426|  5.91k|            , bufToUse.getRawBuffer()
  427|  5.91k|            , parentElem.getFullName()
  428|  5.91k|        );
  429|       |
  430|       |        // Use the dummy decl to parse into and set its name to the name we got
  431|  5.91k|        if (!fDumAttDef)
  ------------------
  |  Branch (431:13): [True: 277, False: 5.63k]
  ------------------
  432|    277|        {
  433|    277|            fDumAttDef = new (fMemoryManager) DTDAttDef(fMemoryManager);
  434|    277|            fDumAttDef->setId(fNextAttrId++);
  435|    277|        }
  436|  5.91k|        fDumAttDef->setName(bufToUse.getRawBuffer());
  437|  5.91k|        decl = fDumAttDef;
  438|  5.91k|    }
  439|  9.22k|     else
  440|  9.22k|    {
  441|       |        //
  442|       |        //  It does not already exist so create a new one, give it the next
  443|       |        //  available unique id, and add it
  444|       |        //
  445|  9.22k|        decl = new (fGrammarPoolMemoryManager) DTDAttDef
  446|  9.22k|        (
  447|  9.22k|            bufToUse.getRawBuffer()
  448|  9.22k|            , XMLAttDef::CData
  449|  9.22k|            , XMLAttDef::Implied
  450|  9.22k|            , fGrammarPoolMemoryManager
  451|  9.22k|        );
  452|  9.22k|        decl->setId(fNextAttrId++);
  453|  9.22k|        decl->setExternalAttDeclaration(isReadingExternalEntity());
  454|  9.22k|        parentElem.addAttDef(decl);
  455|  9.22k|    }
  456|       |
  457|       |    // Set a flag to indicate whether we are doing a dummy parse
  458|  15.1k|    const bool isIgnored = (decl == fDumAttDef);
  459|       |
  460|       |    // Space is required here, so check for PE ref, and require space
  461|  15.1k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (461:9): [True: 1, False: 15.1k]
  ------------------
  462|      1|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
  463|       |
  464|       |    //
  465|       |    //  Next has to be one of the attribute type strings. This tells us what
  466|       |    //  is to follow.
  467|       |    //
  468|  15.1k|    if (fReaderMgr->skippedString(XMLUni::fgCDATAString))
  ------------------
  |  Branch (468:9): [True: 9.82k, False: 5.30k]
  ------------------
  469|  9.82k|    {
  470|  9.82k|        decl->setType(XMLAttDef::CData);
  471|  9.82k|    }
  472|  5.30k|     else if (fReaderMgr->skippedString(XMLUni::fgIDString))
  ------------------
  |  Branch (472:15): [True: 3.62k, False: 1.68k]
  ------------------
  473|  3.62k|    {
  474|  3.62k|        if (!fReaderMgr->skippedString(XMLUni::fgRefString))
  ------------------
  |  Branch (474:13): [True: 2.53k, False: 1.09k]
  ------------------
  475|  2.53k|            decl->setType(XMLAttDef::ID);
  476|  1.09k|        else if (!fReaderMgr->skippedChar(chLatin_S))
  ------------------
  |  Branch (476:18): [True: 529, False: 562]
  ------------------
  477|    529|            decl->setType(XMLAttDef::IDRef);
  478|    562|        else
  479|    562|            decl->setType(XMLAttDef::IDRefs);
  480|  3.62k|    }
  481|  1.68k|     else if (fReaderMgr->skippedString(XMLUni::fgEntitString))
  ------------------
  |  Branch (481:15): [True: 1.04k, False: 638]
  ------------------
  482|  1.04k|    {
  483|  1.04k|        if (fReaderMgr->skippedChar(chLatin_Y))
  ------------------
  |  Branch (483:13): [True: 529, False: 515]
  ------------------
  484|    529|        {
  485|    529|            decl->setType(XMLAttDef::Entity);
  486|    529|        }
  487|    515|         else if (fReaderMgr->skippedString(XMLUni::fgIESString))
  ------------------
  |  Branch (487:19): [True: 514, False: 1]
  ------------------
  488|    514|        {
  489|    514|            decl->setType(XMLAttDef::Entities);
  490|    514|        }
  491|      1|         else
  492|      1|        {
  493|      1|            fScanner->emitError
  494|      1|            (
  495|      1|                XMLErrs::ExpectedAttributeType
  496|      1|                , decl->getFullName()
  497|      1|                , parentElem.getFullName()
  498|      1|            );
  499|      1|            return 0;
  500|      1|        }
  501|  1.04k|    }
  502|    638|     else if (fReaderMgr->skippedString(XMLUni::fgNmTokenString))
  ------------------
  |  Branch (502:15): [True: 603, False: 35]
  ------------------
  503|    603|    {
  504|    603|        if (fReaderMgr->skippedChar(chLatin_S))
  ------------------
  |  Branch (504:13): [True: 303, False: 300]
  ------------------
  505|    303|            decl->setType(XMLAttDef::NmTokens);
  506|    300|        else
  507|    300|            decl->setType(XMLAttDef::NmToken);
  508|    603|    }
  509|     35|     else if (fReaderMgr->skippedString(XMLUni::fgNotationString))
  ------------------
  |  Branch (509:15): [True: 2, False: 33]
  ------------------
  510|      2|    {
  511|       |        // Check for PE ref and require space
  512|      2|        if (!checkForPERef(false, true))
  ------------------
  |  Branch (512:13): [True: 1, False: 1]
  ------------------
  513|      1|            fScanner->emitError(XMLErrs::ExpectedWhitespace);
  514|       |
  515|      2|        decl->setType(XMLAttDef::Notation);
  516|      2|        if (!scanEnumeration(*decl, bufToUse, true))
  ------------------
  |  Branch (516:13): [True: 0, False: 2]
  ------------------
  517|      0|            return 0;
  518|       |
  519|       |        // Set the value as the enumeration for this decl
  520|      2|        decl->setEnumeration(bufToUse.getRawBuffer());
  521|      2|    }
  522|     33|     else if (fReaderMgr->skippedChar(chOpenParen))
  ------------------
  |  Branch (522:15): [True: 13, False: 20]
  ------------------
  523|     13|    {
  524|     13|        decl->setType(XMLAttDef::Enumeration);
  525|     13|        if (!scanEnumeration(*decl, bufToUse, false))
  ------------------
  |  Branch (525:13): [True: 0, False: 13]
  ------------------
  526|      0|            return 0;
  527|       |
  528|       |        // Set the value as the enumeration for this decl
  529|     13|        decl->setEnumeration(bufToUse.getRawBuffer());
  530|     13|    }
  531|     20|     else
  532|     20|    {
  533|     20|        fScanner->emitError
  534|     20|        (
  535|     20|            XMLErrs::ExpectedAttributeType
  536|     20|            , decl->getFullName()
  537|     20|            , parentElem.getFullName()
  538|     20|        );
  539|     20|        return 0;
  540|     20|    }
  541|       |
  542|       |    // Space is required here, so check for PE ref, and require space
  543|  15.1k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (543:9): [True: 3, False: 15.1k]
  ------------------
  544|      3|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
  545|       |
  546|       |    // And then scan for the optional default value declaration
  547|  15.1k|    scanDefaultDecl(*decl);
  548|       |
  549|       |    // If validating, then do a couple of validation constraints
  550|  15.1k|    if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (550:9): [True: 0, False: 15.1k]
  ------------------
  551|      0|    {
  552|      0|        if (decl->getType() == XMLAttDef::ID)
  ------------------
  |  Branch (552:13): [True: 0, False: 0]
  ------------------
  553|      0|        {
  554|      0|            if ((decl->getDefaultType() != XMLAttDef::Implied)
  ------------------
  |  Branch (554:17): [True: 0, False: 0]
  ------------------
  555|      0|            &&  (decl->getDefaultType() != XMLAttDef::Required))
  ------------------
  |  Branch (555:17): [True: 0, False: 0]
  ------------------
  556|      0|            {
  557|      0|                fScanner->getValidator()->emitError(XMLValid::BadIDAttrDefType, decl->getFullName());
  558|      0|            }
  559|      0|        }
  560|       |
  561|       |        // if attdef is xml:space, check correct enumeration (default|preserve)
  562|      0|        const XMLCh fgXMLSpace[] = { chLatin_x, chLatin_m, chLatin_l, chColon, chLatin_s, chLatin_p, chLatin_a, chLatin_c, chLatin_e, chNull };
  563|       |
  564|      0|        if (XMLString::equals(decl->getFullName(),fgXMLSpace)) {
  ------------------
  |  Branch (564:13): [True: 0, False: 0]
  ------------------
  565|      0|            const XMLCh fgPreserve[] = { chLatin_p, chLatin_r, chLatin_e, chLatin_s, chLatin_e, chLatin_r, chLatin_v, chLatin_e, chNull };
  566|      0|            const XMLCh fgDefault[] = { chLatin_d, chLatin_e, chLatin_f, chLatin_a, chLatin_u, chLatin_l, chLatin_t, chNull };
  567|      0|            bool ok = false;
  568|      0|            if (decl->getType() == XMLAttDef::Enumeration) {
  ------------------
  |  Branch (568:17): [True: 0, False: 0]
  ------------------
  569|      0|                BaseRefVectorOf<XMLCh>* enumVector = XMLString::tokenizeString(decl->getEnumeration(), fMemoryManager);
  570|      0|                XMLSize_t size = enumVector->size();
  571|      0|                ok = (size == 1 &&
  ------------------
  |  Branch (571:23): [True: 0, False: 0]
  ------------------
  572|      0|                     (XMLString::equals(enumVector->elementAt(0), fgDefault) ||
  ------------------
  |  Branch (572:23): [True: 0, False: 0]
  ------------------
  573|      0|                      XMLString::equals(enumVector->elementAt(0), fgPreserve))) ||
  ------------------
  |  Branch (573:23): [True: 0, False: 0]
  ------------------
  574|      0|                     (size == 2 &&
  ------------------
  |  Branch (574:23): [True: 0, False: 0]
  ------------------
  575|      0|                     (XMLString::equals(enumVector->elementAt(0), fgDefault) &&
  ------------------
  |  Branch (575:23): [True: 0, False: 0]
  ------------------
  576|      0|                      XMLString::equals(enumVector->elementAt(1), fgPreserve))) ||
  ------------------
  |  Branch (576:23): [True: 0, False: 0]
  ------------------
  577|      0|                     (size == 2 &&
  ------------------
  |  Branch (577:23): [True: 0, False: 0]
  ------------------
  578|      0|                     (XMLString::equals(enumVector->elementAt(1), fgDefault) &&
  ------------------
  |  Branch (578:23): [True: 0, False: 0]
  ------------------
  579|      0|                      XMLString::equals(enumVector->elementAt(0), fgPreserve)));
  ------------------
  |  Branch (579:23): [True: 0, False: 0]
  ------------------
  580|      0|                delete enumVector;
  581|      0|            }
  582|      0|            if (!ok)
  ------------------
  |  Branch (582:17): [True: 0, False: 0]
  ------------------
  583|      0|                fScanner->getValidator()->emitError(XMLValid::IllegalXMLSpace);
  584|      0|        }
  585|      0|    }
  586|       |
  587|       |    // If we have a doc type handler, tell it about this attdef.
  588|  15.1k|    if (fDocTypeHandler)
  ------------------
  |  Branch (588:9): [True: 0, False: 15.1k]
  ------------------
  589|      0|        fDocTypeHandler->attDef(parentElem, *decl, isIgnored);
  590|  15.1k|    return decl;
  591|  15.1k|}
_ZN11xercesc_3_210DTDScanner15scanAttListDeclEv:
  595|  2.63k|{
  596|       |    // Space is required here, so check for a PE ref
  597|  2.63k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (597:9): [True: 0, False: 2.63k]
  ------------------
  598|      0|    {
  599|      0|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
  600|      0|        fReaderMgr->skipPastChar(chCloseAngle);
  601|      0|        return;
  602|      0|    }
  603|       |
  604|       |    //
  605|       |    //  Next should be the name of the element it belongs to, so get a buffer
  606|       |    //  and get the name into it.
  607|       |    //
  608|  2.63k|    XMLBufBid bbName(fBufMgr);
  609|  2.63k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (609:9): [True: 3, False: 2.63k]
  ------------------
  610|      3|    {
  611|      3|        fScanner->emitError(XMLErrs::ExpectedElementName);
  612|      3|        fReaderMgr->skipPastChar(chCloseAngle);
  613|      3|        return;
  614|      3|    }
  615|       |
  616|       |    //
  617|       |    //  Find this element's declaration. If it has not been declared yet,
  618|       |    //  we will force one into the list, but not mark it as declared.
  619|       |    //
  620|  2.63k|    DTDElementDecl* elemDecl = (DTDElementDecl*) fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, bbName.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
  621|  2.63k|    if (!elemDecl)
  ------------------
  |  Branch (621:9): [True: 731, False: 1.90k]
  ------------------
  622|    731|    {
  623|       |        //
  624|       |        //  Lets fault in a declaration and add it to the pool. We mark
  625|       |        //  it having been created because of an attlist. Later, if its
  626|       |        //  declared, this will be updated.
  627|       |        //
  628|    731|        elemDecl = new (fGrammarPoolMemoryManager) DTDElementDecl
  629|    731|        (
  630|    731|            bbName.getRawBuffer()
  631|    731|            , fEmptyNamespaceId
  632|    731|            , DTDElementDecl::Any
  633|    731|            , fGrammarPoolMemoryManager
  634|    731|        );
  635|    731|        elemDecl->setCreateReason(XMLElementDecl::AttList);
  636|    731|        elemDecl->setExternalElemDeclaration(isReadingExternalEntity());
  637|    731|        fDTDGrammar->putElemDecl((XMLElementDecl*) elemDecl);
  638|    731|    }
  639|       |
  640|       |    // If we have a doc type handler, tell it the att list is starting
  641|  2.63k|    if (fDocTypeHandler)
  ------------------
  |  Branch (641:9): [True: 0, False: 2.63k]
  ------------------
  642|      0|        fDocTypeHandler->startAttList(*elemDecl);
  643|       |
  644|       |    //
  645|       |    //  Now we loop until we are done with all of the attributes in this
  646|       |    //  list. We need a buffer to use for local processing.
  647|       |    //
  648|  2.63k|    XMLBufBid   bbTmp(fBufMgr);
  649|  2.63k|    XMLBuffer&  tmpBuf = bbTmp.getBuffer();
  650|  2.63k|    bool        seenAnId = false;
  651|  32.9k|    while (true)
  ------------------
  |  Branch (651:12): [Folded - Ignored]
  ------------------
  652|  32.7k|    {
  653|       |        // Get the next char out and see what it tells us to do
  654|  32.7k|        const XMLCh nextCh = fReaderMgr->peekNextChar();
  655|       |
  656|       |        // Watch for EOF
  657|  32.7k|        if (!nextCh)
  ------------------
  |  Branch (657:13): [True: 0, False: 32.7k]
  ------------------
  658|      0|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  659|       |
  660|  32.7k|        if (nextCh == chCloseAngle)
  ------------------
  |  Branch (660:13): [True: 2.49k, False: 30.2k]
  ------------------
  661|  2.49k|        {
  662|       |            // We are done with this attribute list
  663|  2.49k|            fReaderMgr->getNextChar();
  664|  2.49k|            break;
  665|  2.49k|        }
  666|  30.2k|         else if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (666:19): [True: 15.1k, False: 15.1k]
  ------------------
  667|  15.1k|        {
  668|       |            //
  669|       |            //  If advanced callbacks are enabled and we have a doc
  670|       |            //  type handler, then gather up the white space and call
  671|       |            //  back on the doctype handler. Otherwise, just skip
  672|       |            //  whitespace.
  673|       |            //
  674|  15.1k|            if (fDocTypeHandler)
  ------------------
  |  Branch (674:17): [True: 0, False: 15.1k]
  ------------------
  675|      0|            {
  676|      0|                fReaderMgr->getSpaces(tmpBuf);
  677|      0|                fDocTypeHandler->doctypeWhitespace
  678|      0|                (
  679|      0|                    tmpBuf.getRawBuffer()
  680|      0|                    , tmpBuf.getLen()
  681|      0|                );
  682|      0|            }
  683|  15.1k|             else
  684|  15.1k|            {
  685|  15.1k|                fReaderMgr->skipPastSpaces();
  686|  15.1k|            }
  687|  15.1k|        }
  688|  15.1k|         else if (nextCh == chPercent)
  ------------------
  |  Branch (688:19): [True: 1, False: 15.1k]
  ------------------
  689|      1|        {
  690|       |            // Eat the percent and expand the ref
  691|      1|            fReaderMgr->getNextChar();
  692|      1|            expandPERef(false, false, true);
  693|      1|        }
  694|  15.1k|         else
  695|  15.1k|        {
  696|       |            //
  697|       |            //  It must be an attribute name, so scan it. We let
  698|       |            //  it use our local buffer for its name scanning.
  699|       |            //
  700|  15.1k|            XMLAttDef* attDef = scanAttDef(*elemDecl, tmpBuf);
  701|       |
  702|  15.1k|            if (!attDef)
  ------------------
  |  Branch (702:17): [True: 0, False: 15.1k]
  ------------------
  703|      0|            {
  704|      0|                fReaderMgr->skipPastChar(chCloseAngle);
  705|      0|                break;
  706|      0|            }
  707|       |
  708|       |            //
  709|       |            //  If we are validating and its an ID type, then we have to
  710|       |            //  make sure that we have not seen an id attribute yet. Set
  711|       |            //  the flag to say that we've seen one now also.
  712|       |            //
  713|  15.1k|            if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (713:17): [True: 0, False: 15.1k]
  ------------------
  714|      0|            {
  715|      0|                if (attDef->getType() == XMLAttDef::ID)
  ------------------
  |  Branch (715:21): [True: 0, False: 0]
  ------------------
  716|      0|                {
  717|      0|                    if (seenAnId)
  ------------------
  |  Branch (717:25): [True: 0, False: 0]
  ------------------
  718|      0|                        fScanner->getValidator()->emitError(XMLValid::MultipleIdAttrs, elemDecl->getFullName());
  719|      0|                    seenAnId = true;
  720|      0|                }
  721|      0|            }
  722|  15.1k|        }
  723|  32.7k|    }
  724|       |
  725|       |    // If we have a doc type handler, tell it the att list is ending
  726|  2.63k|    if (fDocTypeHandler)
  ------------------
  |  Branch (726:9): [True: 0, False: 2.63k]
  ------------------
  727|      0|        fDocTypeHandler->endAttList(*elemDecl);
  728|  2.63k|}
_ZN11xercesc_3_210DTDScanner12scanAttValueEPKDsRNS_9XMLBufferENS_9XMLAttDef8AttTypesE:
  746|  1.65k|{
  747|  1.65k|    enum States
  748|  1.65k|    {
  749|  1.65k|        InWhitespace
  750|  1.65k|        , InContent
  751|  1.65k|    };
  752|       |
  753|       |    // Reset the target buffer
  754|  1.65k|    toFill.reset();
  755|       |
  756|       |    // Get the next char which must be a single or double quote
  757|  1.65k|    XMLCh quoteCh;
  758|  1.65k|    if (!fReaderMgr->skipIfQuote(quoteCh))
  ------------------
  |  Branch (758:9): [True: 27, False: 1.62k]
  ------------------
  759|     27|        return false;
  760|       |
  761|       |    //
  762|       |    //  We have to get the current reader because we have to ignore closing
  763|       |    //  quotes until we hit the same reader again.
  764|       |    //
  765|  1.62k|    const XMLSize_t curReader = fReaderMgr->getCurrentReaderNum();
  766|       |
  767|       |    //
  768|       |    //  Loop until we get the attribute value. Note that we use a double
  769|       |    //  loop here to avoid the setup/teardown overhead of the exception
  770|       |    //  handler on every round.
  771|       |    //
  772|  1.62k|    XMLCh   nextCh;
  773|  1.62k|    XMLCh   secondCh = 0;
  774|  1.62k|    States  curState = InContent;
  775|  1.62k|    bool    firstNonWS = false;
  776|  1.62k|    bool    gotLeadingSurrogate = false;
  777|  1.62k|    bool    escaped;
  778|  1.62k|    while (true)
  ------------------
  |  Branch (778:12): [Folded - Ignored]
  ------------------
  779|  1.62k|    {
  780|  1.62k|    try
  781|  1.62k|    {
  782|  80.3M|        while(true)
  ------------------
  |  Branch (782:15): [Folded - Ignored]
  ------------------
  783|  80.3M|        {
  784|  80.3M|            nextCh = fReaderMgr->getNextChar();
  785|       |
  786|  80.3M|            if (!nextCh)
  ------------------
  |  Branch (786:17): [True: 0, False: 80.3M]
  ------------------
  787|      0|                ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  788|       |
  789|       |            // Check for our ending quote in the same entity
  790|  80.3M|            if (nextCh == quoteCh)
  ------------------
  |  Branch (790:17): [True: 1.83k, False: 80.3M]
  ------------------
  791|  1.83k|            {
  792|  1.83k|                if (curReader == fReaderMgr->getCurrentReaderNum())
  ------------------
  |  Branch (792:21): [True: 1.55k, False: 279]
  ------------------
  793|  1.55k|                    return true;
  794|       |
  795|       |                // Watch for spillover into a previous entity
  796|    279|                if (curReader > fReaderMgr->getCurrentReaderNum())
  ------------------
  |  Branch (796:21): [True: 0, False: 279]
  ------------------
  797|      0|                {
  798|      0|                    fScanner->emitError(XMLErrs::PartialMarkupInEntity);
  799|      0|                    return false;
  800|      0|                }
  801|    279|            }
  802|       |
  803|       |            //
  804|       |            //  Check for an entity ref now, before we let it affect our
  805|       |            //  whitespace normalization logic below. We ignore the empty flag
  806|       |            //  in this one.
  807|       |            //
  808|  80.3M|            escaped = false;
  809|  80.3M|            if (nextCh == chAmpersand)
  ------------------
  |  Branch (809:17): [True: 14.6k, False: 80.3M]
  ------------------
  810|  14.6k|            {
  811|  14.6k|                if (scanEntityRef(nextCh, secondCh, escaped) != EntityExp_Returned)
  ------------------
  |  Branch (811:21): [True: 13.2k, False: 1.38k]
  ------------------
  812|  13.2k|                {
  813|  13.2k|                    gotLeadingSurrogate = false;
  814|  13.2k|                    continue;
  815|  13.2k|                }
  816|  14.6k|            }
  817|  80.3M|            else if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (817:22): [True: 696, False: 80.3M]
  |  Branch (817:44): [True: 299, False: 397]
  ------------------
  818|    299|            {
  819|       |                // Check for correct surrogate pairs
  820|    299|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (820:21): [True: 0, False: 299]
  ------------------
  821|      0|                    fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
  822|    299|                else
  823|    299|                    gotLeadingSurrogate = true;
  824|    299|            }
  825|  80.3M|             else
  826|  80.3M|            {
  827|  80.3M|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (827:21): [True: 299, False: 80.3M]
  ------------------
  828|    299|                {
  829|    299|                    if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
  ------------------
  |  Branch (829:25): [True: 0, False: 299]
  |  Branch (829:46): [True: 0, False: 299]
  ------------------
  830|      0|                        fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
  831|    299|                }
  832|       |                // Its got to at least be a valid XML character
  833|  80.3M|                else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh))
  ------------------
  |  Branch (833:26): [True: 1, False: 80.3M]
  ------------------
  834|      1|                {
  835|      1|                    XMLCh tmpBuf[9];
  836|      1|                    XMLString::binToText
  837|      1|                    (
  838|      1|                        nextCh
  839|      1|                        , tmpBuf
  840|      1|                        , 8
  841|      1|                        , 16
  842|      1|                        , fMemoryManager
  843|      1|                    );
  844|      1|                    fScanner->emitError
  845|      1|                    (
  846|      1|                        XMLErrs::InvalidCharacterInAttrValue
  847|      1|                        , attrName
  848|      1|                        , tmpBuf
  849|      1|                    );
  850|      1|                }
  851|       |
  852|  80.3M|                gotLeadingSurrogate = false;
  853|  80.3M|            }
  854|       |
  855|       |            //
  856|       |            //  If its not escaped, then make sure its not a < character, which
  857|       |            //  is not allowed in attribute values.
  858|       |            //
  859|  80.3M|            if (!escaped && (nextCh == chOpenAngle))
  ------------------
  |  Branch (859:17): [True: 80.3M, False: 1.38k]
  |  Branch (859:29): [True: 1, False: 80.3M]
  ------------------
  860|      1|                fScanner->emitError(XMLErrs::BracketInAttrValue, attrName);
  861|       |
  862|       |            //
  863|       |            //  If the attribute is a CDATA type we do simple replacement of
  864|       |            //  tabs and new lines with spaces, if the character is not escaped
  865|       |            //  by way of a char ref.
  866|       |            //
  867|       |            //  Otherwise, we do the standard non-CDATA normalization of
  868|       |            //  compressing whitespace to single spaces and getting rid of
  869|       |            //  leading and trailing whitespace.
  870|       |            //
  871|  80.3M|            if (type == XMLAttDef::CData)
  ------------------
  |  Branch (871:17): [True: 15.9M, False: 64.3M]
  ------------------
  872|  15.9M|            {
  873|  15.9M|                if (!escaped)
  ------------------
  |  Branch (873:21): [True: 15.9M, False: 650]
  ------------------
  874|  15.9M|                {
  875|  15.9M|                    if ((nextCh == 0x09) || (nextCh == 0x0A) || (nextCh == 0x0D))
  ------------------
  |  Branch (875:25): [True: 1.12k, False: 15.9M]
  |  Branch (875:45): [True: 3.96k, False: 15.9M]
  |  Branch (875:65): [True: 232, False: 15.9M]
  ------------------
  876|  5.32k|                        nextCh = chSpace;
  877|  15.9M|                }
  878|  15.9M|            }
  879|  64.3M|             else
  880|  64.3M|            {
  881|  64.3M|                if (curState == InWhitespace)
  ------------------
  |  Branch (881:21): [True: 165k, False: 64.2M]
  ------------------
  882|   165k|                {
  883|   165k|                    if (!fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (883:25): [True: 74.5k, False: 90.7k]
  ------------------
  884|  74.5k|                    {
  885|  74.5k|                        if (firstNonWS)
  ------------------
  |  Branch (885:29): [True: 74.3k, False: 230]
  ------------------
  886|  74.3k|                            toFill.append(chSpace);
  887|  74.5k|                        curState = InContent;
  888|  74.5k|                        firstNonWS = true;
  889|  74.5k|                    }
  890|  90.7k|                     else
  891|  90.7k|                    {
  892|  90.7k|                        continue;
  893|  90.7k|                    }
  894|   165k|                }
  895|  64.2M|                 else if (curState == InContent)
  ------------------
  |  Branch (895:27): [True: 64.2M, False: 67]
  ------------------
  896|  64.2M|                {
  897|  64.2M|                    if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (897:25): [True: 74.5k, False: 64.1M]
  ------------------
  898|  74.5k|                    {
  899|  74.5k|                        curState = InWhitespace;
  900|  74.5k|                        continue;
  901|  74.5k|                    }
  902|  64.1M|                    firstNonWS = true;
  903|  64.1M|                }
  904|  64.3M|            }
  905|       |
  906|       |            // Else add it to the buffer
  907|  80.1M|            toFill.append(nextCh);
  908|       |
  909|  80.1M|            if (secondCh)
  ------------------
  |  Branch (909:17): [True: 331, False: 80.1M]
  ------------------
  910|    331|            {
  911|    331|                toFill.append(secondCh);
  912|    331|                secondCh=0;
  913|    331|            }
  914|  80.1M|        }
  915|  1.62k|    }
  916|       |
  917|  1.62k|    catch(const EndOfEntityException&)
  918|  1.62k|    {
  919|       |        // Just eat it and continue.
  920|      0|        gotLeadingSurrogate = false;
  921|      0|        escaped = false;
  922|      0|    }
  923|  1.62k|    }
  924|      0|    return true;
  925|  1.62k|}
_ZN11xercesc_3_210DTDScanner11scanCharRefERDsS1_:
  929|  4.81k|{
  930|  4.81k|    bool gotOne = false;
  931|  4.81k|    unsigned int value = 0;
  932|       |
  933|       |    //
  934|       |    //  Set the radix. Its supposed to be a lower case x if hex. But, in
  935|       |    //  order to recover well, we check for an upper and put out an error
  936|       |    //  for that.
  937|       |    //
  938|  4.81k|    unsigned int radix = 10;
  939|       |
  940|  4.81k|    if (fReaderMgr->skippedChar(chLatin_x))
  ------------------
  |  Branch (940:9): [True: 1.27k, False: 3.54k]
  ------------------
  941|  1.27k|    {
  942|  1.27k|        radix = 16;
  943|  1.27k|    }
  944|  3.54k|     else if (fReaderMgr->skippedChar(chLatin_X))
  ------------------
  |  Branch (944:15): [True: 3, False: 3.53k]
  ------------------
  945|      3|    {
  946|      3|        fScanner->emitError(XMLErrs::HexRadixMustBeLowerCase);
  947|      3|        radix = 16;
  948|      3|    }
  949|       |
  950|  16.1k|    while (true)
  ------------------
  |  Branch (950:12): [Folded - Ignored]
  ------------------
  951|  16.1k|    {
  952|  16.1k|        const XMLCh nextCh = fReaderMgr->peekNextChar();
  953|       |
  954|       |        // Watch for EOF
  955|  16.1k|        if (!nextCh)
  ------------------
  |  Branch (955:13): [True: 2, False: 16.1k]
  ------------------
  956|      2|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      2|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  957|       |
  958|       |        // Break out on the terminating semicolon
  959|  16.1k|        if (nextCh == chSemiColon)
  ------------------
  |  Branch (959:13): [True: 4.72k, False: 11.4k]
  ------------------
  960|  4.72k|        {
  961|  4.72k|            fReaderMgr->getNextChar();
  962|  4.72k|            break;
  963|  4.72k|        }
  964|       |
  965|       |        //
  966|       |        //  Convert this char to a binary value, or bail out if its not
  967|       |        //  one.
  968|       |        //
  969|  11.4k|        unsigned int nextVal;
  970|  11.4k|        if ((nextCh >= chDigit_0) && (nextCh <= chDigit_9))
  ------------------
  |  Branch (970:13): [True: 11.3k, False: 11]
  |  Branch (970:38): [True: 9.61k, False: 1.77k]
  ------------------
  971|  9.61k|            nextVal = (unsigned int)(nextCh - chDigit_0);
  972|  1.78k|        else if ((nextCh >= chLatin_A) && (nextCh <= chLatin_F))
  ------------------
  |  Branch (972:18): [True: 1.77k, False: 12]
  |  Branch (972:43): [True: 910, False: 862]
  ------------------
  973|    910|            nextVal= (unsigned int)(10 + (nextCh - chLatin_A));
  974|    874|        else if ((nextCh >= chLatin_a) && (nextCh <= chLatin_f))
  ------------------
  |  Branch (974:18): [True: 850, False: 24]
  |  Branch (974:43): [True: 803, False: 47]
  ------------------
  975|    803|            nextVal = (unsigned int)(10 + (nextCh - chLatin_a));
  976|     71|        else
  977|     71|        {
  978|       |            //
  979|       |            //  If we got at least a sigit, then do an unterminated ref
  980|       |            //  error. Else, do an expected a numerical ref thing.
  981|       |            //
  982|     71|            if (gotOne)
  ------------------
  |  Branch (982:17): [True: 26, False: 45]
  ------------------
  983|     26|                fScanner->emitError(XMLErrs::UnterminatedCharRef);
  984|     45|            else
  985|     45|                fScanner->emitError(XMLErrs::ExpectedNumericalCharRef);
  986|       |
  987|     71|            return false;
  988|     71|        }
  989|       |
  990|       |        //
  991|       |        //  Make sure its valid for the radix. If not, then just eat the
  992|       |        //  digit and go on after issueing an error. Else, update the
  993|       |        //  running value with this new digit.
  994|       |        //
  995|  11.3k|        if (nextVal >= radix)
  ------------------
  |  Branch (995:13): [True: 14, False: 11.3k]
  ------------------
  996|     14|        {
  997|     14|            XMLCh tmpStr[2];
  998|     14|            tmpStr[0] = nextCh;
  999|     14|            tmpStr[1] = chNull;
 1000|     14|            fScanner->emitError(XMLErrs::BadDigitForRadix, tmpStr);
 1001|     14|        }
 1002|  11.3k|         else
 1003|  11.3k|        {
 1004|  11.3k|            value = (value * radix) + nextVal;
 1005|  11.3k|        }
 1006|       |
 1007|       |        // Indicate that we got at least one good digit
 1008|  11.3k|        gotOne = true;
 1009|       |
 1010|       |        // Eat the char we just processed
 1011|  11.3k|        fReaderMgr->getNextChar();
 1012|  11.3k|    }
 1013|       |
 1014|       |    // Return the char (or chars)
 1015|       |    // And check if the character expanded is valid or not
 1016|  4.74k|    if (value >= 0x10000 && value <= 0x10FFFF)
  ------------------
  |  Branch (1016:9): [True: 995, False: 3.75k]
  |  Branch (1016:29): [True: 949, False: 46]
  ------------------
 1017|    949|    {
 1018|    949|        value -= 0x10000;
 1019|    949|        first  = XMLCh((value >> 10) + 0xD800);
 1020|    949|        second = XMLCh((value & 0x3FF) + 0xDC00);
 1021|    949|    }
 1022|  3.79k|    else if (value <= 0xFFFD)
  ------------------
  |  Branch (1022:14): [True: 3.73k, False: 64]
  ------------------
 1023|  3.73k|    {
 1024|  3.73k|        first  = XMLCh(value);
 1025|  3.73k|        second = 0;
 1026|  3.73k|        if (!fReaderMgr->getCurrentReader()->isXMLChar(first) && !fReaderMgr->getCurrentReader()->isControlChar(first)) {
  ------------------
  |  Branch (1026:13): [True: 83, False: 3.65k]
  |  Branch (1026:66): [True: 5, False: 78]
  ------------------
 1027|       |            // Character reference was not in the valid range
 1028|      5|            fScanner->emitError(XMLErrs::InvalidCharacterRef);
 1029|      5|            return false;
 1030|      5|        }
 1031|  3.73k|    }
 1032|     64|    else {
 1033|       |        // Character reference was not in the valid range
 1034|     64|        fScanner->emitError(XMLErrs::InvalidCharacterRef);
 1035|     64|        return false;
 1036|     64|    }
 1037|       |
 1038|  4.67k|    return true;
 1039|  4.74k|}
_ZN11xercesc_3_210DTDScanner12scanChildrenERKNS_14DTDElementDeclERNS_9XMLBufferERj:
 1044|  23.8k|{
 1045|  23.8k|    if (depth++ > CONTENTSPEC_DEPTH_LIMIT) {
  ------------------
  |  |   47|  23.8k|#define CONTENTSPEC_DEPTH_LIMIT 1000
  ------------------
  |  Branch (1045:9): [True: 1, False: 23.8k]
  ------------------
 1046|      1|        fScanner->emitError(XMLErrs::UnterminatedDOCTYPE);
 1047|      1|        return 0;
 1048|      1|    }
 1049|       |
 1050|       |    // Check for a PE ref here, but don't require spaces
 1051|  23.8k|    checkForPERef(false, true);
 1052|       |
 1053|  23.8k|    ValueStackOf<XMLSize_t>* arrNestedDecl=NULL;
 1054|       |    //
 1055|       |    //  We know that the caller just saw an opening parenthesis, so we need
 1056|       |    //  to parse until we hit the end of it; if we find several parenthesis,
 1057|       |    //  store them in an array to be processed later.
 1058|       |    //
 1059|       |    //  We have to check for one up front, since it could be something like
 1060|       |    //  (((a)*)) etc...
 1061|       |    //
 1062|  23.8k|    ContentSpecNode* curNode = 0;
 1063|  38.4k|    while(fReaderMgr->skippedChar(chOpenParen))
  ------------------
  |  Branch (1063:11): [True: 14.5k, False: 23.8k]
  ------------------
 1064|  14.5k|    {
 1065|       |        // to check entity nesting
 1066|  14.5k|        const XMLSize_t curReader = fReaderMgr->getCurrentReaderNum();
 1067|  14.5k|        if(arrNestedDecl==NULL)
  ------------------
  |  Branch (1067:12): [True: 3.54k, False: 11.0k]
  ------------------
 1068|  3.54k|            arrNestedDecl=new (fMemoryManager) ValueStackOf<XMLSize_t>(5, fMemoryManager);
 1069|  14.5k|        arrNestedDecl->push(curReader);
 1070|       |
 1071|       |        // Check for a PE ref here, but don't require spaces
 1072|  14.5k|        checkForPERef(false, true);
 1073|  14.5k|    }
 1074|       |
 1075|       |    // We must find a leaf node here, either standalone or nested in the parenthesis
 1076|  23.8k|    if (!fReaderMgr->getName(bufToUse))
  ------------------
  |  Branch (1076:9): [True: 13, False: 23.8k]
  ------------------
 1077|     13|    {
 1078|     13|        fScanner->emitError(XMLErrs::ExpectedElementName);
 1079|     13|        return 0;
 1080|     13|    }
 1081|       |
 1082|       |    //
 1083|       |    //  Create a leaf node for it. If we can find the element id for
 1084|       |    //  this element, then use it. Else, we have to fault in an element
 1085|       |    //  decl, marked as created because of being in a content model.
 1086|       |    //
 1087|  23.8k|    XMLElementDecl* decl = fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, bufToUse.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
 1088|  23.8k|    if (!decl)
  ------------------
  |  Branch (1088:9): [True: 4.47k, False: 19.3k]
  ------------------
 1089|  4.47k|    {
 1090|  4.47k|        decl = new (fGrammarPoolMemoryManager) DTDElementDecl
 1091|  4.47k|        (
 1092|  4.47k|            bufToUse.getRawBuffer()
 1093|  4.47k|            , fEmptyNamespaceId
 1094|  4.47k|            , DTDElementDecl::Any
 1095|  4.47k|            , fGrammarPoolMemoryManager
 1096|  4.47k|        );
 1097|  4.47k|        decl->setCreateReason(XMLElementDecl::InContentModel);
 1098|  4.47k|        decl->setExternalElemDeclaration(isReadingExternalEntity());
 1099|  4.47k|        fDTDGrammar->putElemDecl(decl);
 1100|  4.47k|    }
 1101|  23.8k|    curNode = new (fGrammarPoolMemoryManager) ContentSpecNode
 1102|  23.8k|    (
 1103|  23.8k|        decl->getElementName()
 1104|  23.8k|        , fGrammarPoolMemoryManager
 1105|  23.8k|    );
 1106|       |
 1107|       |    // Check for a PE ref here, but don't require spaces
 1108|  23.8k|    const bool gotSpaces = checkForPERef(false, true);
 1109|       |
 1110|       |    // Check for a repetition character after the leaf
 1111|  23.8k|    XMLCh repCh = fReaderMgr->peekNextChar();
 1112|  23.8k|    ContentSpecNode* tmpNode = makeRepNode(repCh, curNode, fGrammarPoolMemoryManager);
 1113|  23.8k|    if (tmpNode != curNode)
  ------------------
  |  Branch (1113:9): [True: 4.95k, False: 18.9k]
  ------------------
 1114|  4.95k|    {
 1115|  4.95k|        if (gotSpaces)
  ------------------
  |  Branch (1115:13): [True: 1, False: 4.95k]
  ------------------
 1116|      1|        {
 1117|      1|            if (fScanner->emitErrorWillThrowException(XMLErrs::UnexpectedWhitespace))
  ------------------
  |  Branch (1117:17): [True: 1, False: 0]
  ------------------
 1118|      1|            {
 1119|      1|                delete tmpNode;
 1120|      1|            }
 1121|      1|            fScanner->emitError(XMLErrs::UnexpectedWhitespace);
 1122|      1|        }
 1123|  4.95k|        fReaderMgr->getNextChar();
 1124|  4.95k|        curNode = tmpNode;
 1125|  4.95k|    }
 1126|       |
 1127|  26.8k|    while(arrNestedDecl==NULL || !arrNestedDecl->empty())
  ------------------
  |  Branch (1127:11): [True: 21.6k, False: 5.16k]
  |  Branch (1127:34): [True: 5.16k, False: 0]
  ------------------
 1128|  26.8k|    {
 1129|       |        // Check for a PE ref here, but don't require spaces
 1130|  26.8k|        checkForPERef(false, true);
 1131|       |
 1132|       |        //
 1133|       |        //  Ok, the next character tells us what kind of content this particular
 1134|       |        //  model this particular parentesized section is. Its either a choice if
 1135|       |        //  we see ',', a sequence if we see '|', or a single leaf node if we see
 1136|       |        //  a closing paren.
 1137|       |        //
 1138|  26.8k|        const XMLCh opCh = fReaderMgr->peekNextChar();
 1139|       |
 1140|  26.8k|        if ((opCh != chComma)
  ------------------
  |  Branch (1140:13): [True: 21.5k, False: 5.26k]
  ------------------
 1141|  26.8k|        &&  (opCh != chPipe)
  ------------------
  |  Branch (1141:13): [True: 9.72k, False: 11.8k]
  ------------------
 1142|  26.8k|        &&  (opCh != chCloseParen))
  ------------------
  |  Branch (1142:13): [True: 61, False: 9.66k]
  ------------------
 1143|     61|        {
 1144|       |            // Not a legal char, so delete our node and return failure
 1145|     61|            delete curNode;
 1146|     61|            fScanner->emitError(XMLErrs::ExpectedSeqChoiceLeaf);
 1147|     61|            return 0;
 1148|     61|        }
 1149|       |
 1150|       |        //
 1151|       |        //  Create the head node of the correct type. We need this to remember
 1152|       |        //  the top of the local tree. If it was a single subexpr, then just
 1153|       |        //  set the head node to the current node. For the others, we'll build
 1154|       |        //  the tree off the second child as we move across.
 1155|       |        //
 1156|  26.7k|        ContentSpecNode* headNode = 0;
 1157|  26.7k|        ContentSpecNode::NodeTypes curType = ContentSpecNode::UnknownType;
 1158|  26.7k|        if (opCh == chComma)
  ------------------
  |  Branch (1158:13): [True: 5.26k, False: 21.4k]
  ------------------
 1159|  5.26k|        {
 1160|  5.26k|            curType = ContentSpecNode::Sequence;
 1161|  5.26k|            headNode = new (fGrammarPoolMemoryManager) ContentSpecNode
 1162|  5.26k|            (
 1163|  5.26k|                curType
 1164|  5.26k|                , curNode
 1165|  5.26k|                , 0
 1166|  5.26k|                , true
 1167|  5.26k|                , true
 1168|  5.26k|                , fGrammarPoolMemoryManager
 1169|  5.26k|            );
 1170|  5.26k|            curNode = headNode;
 1171|  5.26k|        }
 1172|  21.4k|         else if (opCh == chPipe)
  ------------------
  |  Branch (1172:19): [True: 11.8k, False: 9.66k]
  ------------------
 1173|  11.8k|        {
 1174|  11.8k|            curType = ContentSpecNode::Choice;
 1175|  11.8k|            headNode = new (fGrammarPoolMemoryManager) ContentSpecNode
 1176|  11.8k|            (
 1177|  11.8k|                curType
 1178|  11.8k|                , curNode
 1179|  11.8k|                , 0
 1180|  11.8k|                , true
 1181|  11.8k|                , true
 1182|  11.8k|                , fGrammarPoolMemoryManager
 1183|  11.8k|            );
 1184|  11.8k|            curNode = headNode;
 1185|  11.8k|        }
 1186|  9.66k|         else
 1187|  9.66k|        {
 1188|  9.66k|            headNode = curNode;
 1189|  9.66k|            fReaderMgr->getNextChar();
 1190|  9.66k|        }
 1191|       |
 1192|       |        //
 1193|       |        //  If it was a sequence or choice, we just loop until we get to the
 1194|       |        //  end of our section, adding each new leaf or sub expression to the
 1195|       |        //  right child of the current node, and making that new node the current
 1196|       |        //  node.
 1197|       |        //
 1198|  26.7k|        if ((opCh == chComma) || (opCh == chPipe))
  ------------------
  |  Branch (1198:13): [True: 5.26k, False: 21.4k]
  |  Branch (1198:34): [True: 11.8k, False: 9.66k]
  ------------------
 1199|  17.0k|        {
 1200|  17.0k|            ContentSpecNode* lastNode = 0;
 1201|  1.48M|            while (true)
  ------------------
  |  Branch (1201:20): [Folded - Ignored]
  ------------------
 1202|  1.48M|            {
 1203|       |                //
 1204|       |                //  The next thing must either be another | or , character followed
 1205|       |                //  by another leaf or subexpression, or a closing parenthesis, or a
 1206|       |                //  PE ref.
 1207|       |                //
 1208|  1.48M|                if (fReaderMgr->lookingAtChar(chPercent))
  ------------------
  |  Branch (1208:21): [True: 5, False: 1.48M]
  ------------------
 1209|      5|                {
 1210|      5|                    checkForPERef(false, true);
 1211|      5|                }
 1212|  1.48M|                 else if (fReaderMgr->skippedSpace())
  ------------------
  |  Branch (1212:27): [True: 13.8k, False: 1.47M]
  ------------------
 1213|  13.8k|                {
 1214|       |                    // Just skip whitespace
 1215|  13.8k|                    fReaderMgr->skipPastSpaces();
 1216|  13.8k|                }
 1217|  1.47M|                 else if (fReaderMgr->skippedChar(chCloseParen))
  ------------------
  |  Branch (1217:27): [True: 13.3k, False: 1.45M]
  ------------------
 1218|  13.3k|                {
 1219|       |                    //
 1220|       |                    //  We've hit the end of this section, so break out. But, we
 1221|       |                    //  need to see if we left a partial sequence of choice node
 1222|       |                    //  without a second node. If so, we have to undo that and
 1223|       |                    //  put its left child into the right node of the previous
 1224|       |                    //  node.
 1225|       |                    //
 1226|  13.3k|                    if ((curNode->getType() == ContentSpecNode::Choice)
  ------------------
  |  Branch (1226:25): [True: 11.2k, False: 2.04k]
  ------------------
 1227|  13.3k|                    ||  (curNode->getType() == ContentSpecNode::Sequence))
  ------------------
  |  Branch (1227:25): [True: 2.04k, False: 0]
  ------------------
 1228|  13.3k|                    {
 1229|  13.3k|                        if (!curNode->getSecond() && lastNode)
  ------------------
  |  Branch (1229:29): [True: 13.3k, False: 0]
  |  Branch (1229:54): [True: 13.3k, False: 0]
  ------------------
 1230|  13.3k|                        {
 1231|  13.3k|                            ContentSpecNode* saveFirst = curNode->orphanFirst();
 1232|  13.3k|                            lastNode->setSecond(saveFirst);
 1233|  13.3k|                            curNode = lastNode;
 1234|  13.3k|                        }
 1235|  13.3k|                    }
 1236|  13.3k|                    break;
 1237|  13.3k|                }
 1238|  1.45M|                 else if (fReaderMgr->skippedChar(opCh))
  ------------------
  |  Branch (1238:27): [True: 1.45M, False: 56]
  ------------------
 1239|  1.45M|                {
 1240|       |                    // Check for a PE ref here, but don't require spaces
 1241|  1.45M|                    checkForPERef(false, true);
 1242|       |
 1243|  1.45M|                    if (fReaderMgr->skippedChar(chOpenParen))
  ------------------
  |  Branch (1243:25): [True: 21.4k, False: 1.43M]
  ------------------
 1244|  21.4k|                    {
 1245|  21.4k|                        const XMLSize_t curReader = fReaderMgr->getCurrentReaderNum();
 1246|       |
 1247|       |                        // Recurse to handle this new guy
 1248|  21.4k|                        ContentSpecNode* subNode;
 1249|  21.4k|                        try {
 1250|  21.4k|                            subNode = scanChildren(elemDecl, bufToUse, depth);
 1251|  21.4k|                        }
 1252|  21.4k|                        catch (const XMLErrs::Codes)
 1253|  21.4k|                        {
 1254|  3.29k|                            delete headNode;
 1255|  3.29k|                            throw;
 1256|  3.29k|                        }
 1257|       |
 1258|       |                        // If it failed, we are done, clean up here and return failure
 1259|  17.7k|                        if (!subNode)
  ------------------
  |  Branch (1259:29): [True: 0, False: 17.7k]
  ------------------
 1260|      0|                        {
 1261|      0|                            delete headNode;
 1262|      0|                            return 0;
 1263|      0|                        }
 1264|       |
 1265|  17.7k|                        if (curReader != fReaderMgr->getCurrentReaderNum() && fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (1265:29): [True: 0, False: 17.7k]
  |  Branch (1265:79): [True: 0, False: 0]
  ------------------
 1266|      0|                            fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 1267|       |
 1268|       |                        // Else patch it in and make it the new current
 1269|  17.7k|                        ContentSpecNode* newCur = new (fGrammarPoolMemoryManager) ContentSpecNode
 1270|  17.7k|                        (
 1271|  17.7k|                            curType
 1272|  17.7k|                            , subNode
 1273|  17.7k|                            , 0
 1274|  17.7k|                            , true
 1275|  17.7k|                            , true
 1276|  17.7k|                            , fGrammarPoolMemoryManager
 1277|  17.7k|                        );
 1278|  17.7k|                        curNode->setSecond(newCur);
 1279|  17.7k|                        lastNode = curNode;
 1280|  17.7k|                        curNode = newCur;
 1281|  17.7k|                    }
 1282|  1.43M|                     else
 1283|  1.43M|                    {
 1284|       |                        //
 1285|       |                        //  Got to be a leaf node, so get a name. If we cannot get
 1286|       |                        //  one, then clean up and get outa here.
 1287|       |                        //
 1288|  1.43M|                        if (!fReaderMgr->getName(bufToUse))
  ------------------
  |  Branch (1288:29): [True: 7, False: 1.43M]
  ------------------
 1289|      7|                        {
 1290|      7|                            delete headNode;
 1291|      7|                            fScanner->emitError(XMLErrs::ExpectedElementName);
 1292|      7|                            return 0;
 1293|      7|                        }
 1294|       |
 1295|       |                        //
 1296|       |                        //  Create a leaf node for it. If we can find the element
 1297|       |                        //  id for this element, then use it. Else, we have to
 1298|       |                        //  fault in an element decl, marked as created because
 1299|       |                        //  of being in a content model.
 1300|       |                        //
 1301|  1.43M|                        XMLElementDecl* decl = fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, bufToUse.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
 1302|  1.43M|                        if (!decl)
  ------------------
  |  Branch (1302:29): [True: 30.0k, False: 1.40M]
  ------------------
 1303|  30.0k|                        {
 1304|  30.0k|                            decl = new (fGrammarPoolMemoryManager) DTDElementDecl
 1305|  30.0k|                            (
 1306|  30.0k|                                bufToUse.getRawBuffer()
 1307|  30.0k|                                , fEmptyNamespaceId
 1308|  30.0k|                                , DTDElementDecl::Any
 1309|  30.0k|                                , fGrammarPoolMemoryManager
 1310|  30.0k|                            );
 1311|  30.0k|                            decl->setCreateReason(XMLElementDecl::InContentModel);
 1312|  30.0k|                            decl->setExternalElemDeclaration(isReadingExternalEntity());
 1313|  30.0k|                            fDTDGrammar->putElemDecl(decl);
 1314|  30.0k|                        }
 1315|       |
 1316|  1.43M|                        ContentSpecNode* tmpLeaf = new (fGrammarPoolMemoryManager) ContentSpecNode
 1317|  1.43M|                        (
 1318|  1.43M|                            decl->getElementName()
 1319|  1.43M|                            , fGrammarPoolMemoryManager
 1320|  1.43M|                        );
 1321|       |
 1322|       |                        // Check for a repetition character after the leaf
 1323|  1.43M|                        const XMLCh repCh = fReaderMgr->peekNextChar();
 1324|  1.43M|                        ContentSpecNode* tmpLeaf2 = makeRepNode(repCh, tmpLeaf, fGrammarPoolMemoryManager);
 1325|  1.43M|                        if (tmpLeaf != tmpLeaf2)
  ------------------
  |  Branch (1325:29): [True: 29.4k, False: 1.40M]
  ------------------
 1326|  29.4k|                            fReaderMgr->getNextChar();
 1327|       |
 1328|       |                        //
 1329|       |                        //  Create a new sequence or choice node, with the leaf
 1330|       |                        //  (or rep surrounding it) we just got as its first node.
 1331|       |                        //  Make the new node the second node of the current node,
 1332|       |                        //  and then make it the current node.
 1333|       |                        //
 1334|  1.43M|                        ContentSpecNode* newCur = new (fGrammarPoolMemoryManager) ContentSpecNode
 1335|  1.43M|                        (
 1336|  1.43M|                            curType
 1337|  1.43M|                            , tmpLeaf2
 1338|  1.43M|                            , 0
 1339|  1.43M|                            , true
 1340|  1.43M|                            , true
 1341|  1.43M|                            , fGrammarPoolMemoryManager
 1342|  1.43M|                        );
 1343|  1.43M|                        curNode->setSecond(newCur);
 1344|  1.43M|                        lastNode = curNode;
 1345|  1.43M|                        curNode = newCur;
 1346|  1.43M|                    }
 1347|  1.45M|                }
 1348|     56|                 else
 1349|     56|                {
 1350|       |                    // Cannot be valid
 1351|     56|                    delete headNode;  // emitError may do a throw so need to clean-up first
 1352|     56|                    if (opCh == chComma)
  ------------------
  |  Branch (1352:25): [True: 17, False: 39]
  ------------------
 1353|     17|                    {
 1354|     17|                        fScanner->emitError(XMLErrs::ExpectedChoiceOrCloseParen);
 1355|     17|                    }
 1356|     39|                     else
 1357|     39|                    {
 1358|     39|                        fScanner->emitError
 1359|     39|                        (
 1360|     39|                            XMLErrs::ExpectedSeqOrCloseParen
 1361|     39|                            , elemDecl.getFullName()
 1362|     39|                        );
 1363|     39|                    }                
 1364|     56|                    return 0;
 1365|     56|                }
 1366|  1.48M|            }
 1367|  17.0k|        }
 1368|       |
 1369|       |        //
 1370|       |        //  We saw the terminating parenthesis so lets check for any repetition
 1371|       |        //  character, and create a node for that, making the head node the child
 1372|       |        //  of it.
 1373|       |        //
 1374|  23.0k|        const XMLCh repCh = fReaderMgr->peekNextChar();
 1375|  23.0k|        curNode = makeRepNode(repCh, headNode, fGrammarPoolMemoryManager);
 1376|  23.0k|        if (curNode != headNode)
  ------------------
  |  Branch (1376:13): [True: 8.39k, False: 14.6k]
  ------------------
 1377|  8.39k|            fReaderMgr->getNextChar();
 1378|       |
 1379|       |        // prepare for recursion
 1380|  23.0k|        if(arrNestedDecl==NULL)
  ------------------
  |  Branch (1380:12): [True: 20.0k, False: 2.97k]
  ------------------
 1381|  20.0k|            break;
 1382|  2.97k|        else
 1383|  2.97k|        {
 1384|       |            // If that failed, no need to go further, return failure
 1385|  2.97k|            if (!curNode)
  ------------------
  |  Branch (1385:17): [True: 0, False: 2.97k]
  ------------------
 1386|      0|                return 0;
 1387|       |
 1388|  2.97k|            const XMLSize_t curReader = arrNestedDecl->pop();
 1389|  2.97k|            if (curReader != fReaderMgr->getCurrentReaderNum() && fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (1389:17): [True: 0, False: 2.97k]
  |  Branch (1389:67): [True: 0, False: 0]
  ------------------
 1390|      0|                fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 1391|       |
 1392|  2.97k|            if(arrNestedDecl->empty())
  ------------------
  |  Branch (1392:16): [True: 1.32k, False: 1.65k]
  ------------------
 1393|  1.32k|            {
 1394|  1.32k|                delete arrNestedDecl;
 1395|  1.32k|                arrNestedDecl=NULL;
 1396|  1.32k|            }
 1397|  2.97k|        }
 1398|  23.0k|    }
 1399|       |
 1400|  20.0k|    return curNode;
 1401|  23.8k|}
_ZN11xercesc_3_210DTDScanner11scanCommentEv:
 1412|    480|{
 1413|    480|    enum States
 1414|    480|    {
 1415|    480|        InText
 1416|    480|        , OneDash
 1417|    480|        , TwoDashes
 1418|    480|    };
 1419|       |
 1420|       |    // Get a buffer for this
 1421|    480|    XMLBufBid bbComment(fBufMgr);
 1422|       |
 1423|       |    //
 1424|       |    //  Get the comment text into a temp buffer. Be sure to use temp buffer
 1425|       |    //  two here, since its to be used for stuff that is potentially longer
 1426|       |    //  than just a name.
 1427|       |    //
 1428|    480|    bool   gotLeadingSurrogate = false;
 1429|    480|    States curState = InText;
 1430|   423k|    while (true)
  ------------------
  |  Branch (1430:12): [Folded - Ignored]
  ------------------
 1431|   423k|    {
 1432|       |        // Get the next character
 1433|   423k|        const XMLCh nextCh = fReaderMgr->getNextChar();
 1434|       |
 1435|       |        //  Watch for an end of file
 1436|   423k|        if (!nextCh)
  ------------------
  |  Branch (1436:13): [True: 15, False: 423k]
  ------------------
 1437|     15|        {
 1438|     15|            fScanner->emitError(XMLErrs::UnterminatedComment);
 1439|     15|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|     15|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1440|     15|        }
 1441|       |
 1442|       |        // Check for correct surrogate pairs
 1443|   423k|        if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (1443:13): [True: 997, False: 422k]
  |  Branch (1443:35): [True: 400, False: 597]
  ------------------
 1444|    400|        {
 1445|    400|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (1445:17): [True: 0, False: 400]
  ------------------
 1446|      0|                fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
 1447|    400|            else
 1448|    400|                gotLeadingSurrogate = true;
 1449|    400|        }
 1450|   422k|        else
 1451|   422k|        {
 1452|   422k|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (1452:17): [True: 400, False: 422k]
  ------------------
 1453|    400|            {
 1454|    400|                if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
  ------------------
  |  Branch (1454:21): [True: 0, False: 400]
  |  Branch (1454:42): [True: 0, False: 400]
  ------------------
 1455|      0|                    fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
 1456|    400|            }
 1457|       |            // Its got to at least be a valid XML character
 1458|   422k|            else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh)) {
  ------------------
  |  Branch (1458:22): [True: 14, False: 422k]
  ------------------
 1459|       |
 1460|     14|                XMLCh tmpBuf[9];
 1461|     14|                XMLString::binToText
 1462|     14|                (
 1463|     14|                    nextCh
 1464|     14|                    , tmpBuf
 1465|     14|                    , 8
 1466|     14|                    , 16
 1467|     14|                    , fMemoryManager
 1468|     14|                );
 1469|     14|                fScanner->emitError(XMLErrs::InvalidCharacter, tmpBuf);
 1470|     14|            }
 1471|       |
 1472|   422k|            gotLeadingSurrogate = false;
 1473|   422k|        }
 1474|       |
 1475|   423k|        if (curState == InText)
  ------------------
  |  Branch (1475:13): [True: 418k, False: 4.76k]
  ------------------
 1476|   418k|        {
 1477|       |            // If its a dash, go to OneDash state. Otherwise take as text
 1478|   418k|            if (nextCh == chDash)
  ------------------
  |  Branch (1478:17): [True: 4.29k, False: 414k]
  ------------------
 1479|  4.29k|                curState = OneDash;
 1480|   414k|            else
 1481|   414k|                bbComment.append(nextCh);
 1482|   418k|        }
 1483|  4.76k|        else if (curState == OneDash)
  ------------------
  |  Branch (1483:18): [True: 4.29k, False: 465]
  ------------------
 1484|  4.29k|        {
 1485|       |            //
 1486|       |            //  If its another dash, then we change to the two dashes states.
 1487|       |            //  Otherwise, we have to put in the deficit dash and the new
 1488|       |            //  character and go back to InText.
 1489|       |            //
 1490|  4.29k|            if (nextCh == chDash)
  ------------------
  |  Branch (1490:17): [True: 443, False: 3.85k]
  ------------------
 1491|    443|            {
 1492|    443|                curState = TwoDashes;
 1493|    443|            }
 1494|  3.85k|            else
 1495|  3.85k|            {
 1496|  3.85k|                bbComment.append(chDash);
 1497|  3.85k|                bbComment.append(nextCh);
 1498|  3.85k|                curState = InText;
 1499|  3.85k|            }
 1500|  4.29k|        }
 1501|    465|        else if (curState == TwoDashes)
  ------------------
  |  Branch (1501:18): [True: 443, False: 22]
  ------------------
 1502|    443|        {
 1503|       |            // The next character must be the closing bracket
 1504|    443|            if (nextCh != chCloseAngle)
  ------------------
  |  Branch (1504:17): [True: 16, False: 427]
  ------------------
 1505|     16|            {
 1506|     16|                fScanner->emitError(XMLErrs::IllegalSequenceInComment);
 1507|     16|                fReaderMgr->skipPastChar(chCloseAngle);
 1508|     16|                return;
 1509|     16|            }
 1510|    427|            break;
 1511|    443|        }
 1512|   423k|    }
 1513|       |
 1514|       |    // If there is a doc type handler, then pass on the comment stuff
 1515|    449|    if (fDocTypeHandler)
  ------------------
  |  Branch (1515:9): [True: 0, False: 449]
  ------------------
 1516|      0|        fDocTypeHandler->doctypeComment(bbComment.getRawBuffer());
 1517|    449|}
_ZN11xercesc_3_210DTDScanner15scanContentSpecERNS_14DTDElementDeclE:
 1521|  4.56k|{
 1522|       |    //
 1523|       |    //  Check for for a couple of the predefined content type strings. If
 1524|       |    //  its not one of these, its got to be a parenthesized reg ex type
 1525|       |    //  expression.
 1526|       |    //
 1527|  4.56k|    if (fReaderMgr->skippedString(XMLUni::fgEmptyString))
  ------------------
  |  Branch (1527:9): [True: 898, False: 3.67k]
  ------------------
 1528|    898|    {
 1529|    898|        toFill.setModelType(DTDElementDecl::Empty);
 1530|    898|        return true;
 1531|    898|    }
 1532|       |
 1533|  3.67k|    if (fReaderMgr->skippedString(XMLUni::fgAnyString))
  ------------------
  |  Branch (1533:9): [True: 330, False: 3.34k]
  ------------------
 1534|    330|    {
 1535|    330|        toFill.setModelType(DTDElementDecl::Any);
 1536|    330|        return true;
 1537|    330|    }
 1538|       |
 1539|       |    // Its got to be a parenthesized regular expression
 1540|  3.34k|    if (!fReaderMgr->skippedChar(chOpenParen))
  ------------------
  |  Branch (1540:9): [True: 8, False: 3.33k]
  ------------------
 1541|      8|    {
 1542|      8|        fScanner->emitError
 1543|      8|        (
 1544|      8|            XMLErrs::ExpectedContentSpecExpr
 1545|      8|            , toFill.getFullName()
 1546|      8|        );
 1547|      8|        return false;
 1548|      8|    }
 1549|       |
 1550|       |    // Get the current reader id, so we can test for partial markup
 1551|  3.33k|    const XMLSize_t curReader = fReaderMgr->getCurrentReaderNum();
 1552|       |
 1553|       |    // We could have a PE ref here, but don't require space
 1554|  3.33k|    checkForPERef(false, true);
 1555|       |
 1556|       |    //
 1557|       |    //  Now we look for a PCDATA string. If its PCDATA, then it must be a
 1558|       |    //  MIXED model. Otherwise, it must be a regular list of children in
 1559|       |    //  a regular expression perhaps.
 1560|       |    //
 1561|  3.33k|    bool status;
 1562|  3.33k|    if (fReaderMgr->skippedString(XMLUni::fgPCDATAString))
  ------------------
  |  Branch (1562:9): [True: 917, False: 2.41k]
  ------------------
 1563|    917|    {
 1564|       |        // Set the model to mixed
 1565|    917|        toFill.setModelType(DTDElementDecl::Mixed_Simple);
 1566|    917|        status = scanMixed(toFill);
 1567|       |
 1568|       |        //
 1569|       |        //  If we are validating we have to check that there are no multiple
 1570|       |        //  uses of any child elements.
 1571|       |        //
 1572|    917|        if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (1572:13): [True: 0, False: 917]
  ------------------
 1573|      0|        {
 1574|      0|            if (((const MixedContentModel*)toFill.getContentModel())->hasDups())
  ------------------
  |  Branch (1574:17): [True: 0, False: 0]
  ------------------
 1575|      0|                fScanner->getValidator()->emitError(XMLValid::RepElemInMixed);
 1576|      0|        }
 1577|    917|    }
 1578|  2.41k|     else
 1579|  2.41k|    {
 1580|       |        //
 1581|       |        //  We have to do a recursive scan of the content model. Create a
 1582|       |        //  buffer for it to use, for efficiency. It returns the top ofthe
 1583|       |        //  content spec node tree, which we set if successful.
 1584|       |        //
 1585|  2.41k|        toFill.setModelType(DTDElementDecl::Children);
 1586|  2.41k|        XMLBufBid bbTmp(fBufMgr);
 1587|  2.41k|        unsigned int depth = 0;
 1588|  2.41k|        ContentSpecNode* resNode = scanChildren(toFill, bbTmp.getBuffer(), depth);
 1589|  2.41k|        status = (resNode != 0);
 1590|  2.41k|        if (status)
  ------------------
  |  Branch (1590:13): [True: 2.24k, False: 170]
  ------------------
 1591|  2.24k|            toFill.setContentSpec(resNode);
 1592|  2.41k|    }
 1593|       |
 1594|       |    // Make sure we are on the same reader as where we started
 1595|  3.33k|    if (curReader != fReaderMgr->getCurrentReaderNum() && fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (1595:9): [True: 0, False: 3.33k]
  |  Branch (1595:59): [True: 0, False: 0]
  ------------------
 1596|      0|        fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 1597|       |
 1598|  3.33k|    return status;
 1599|  3.34k|}
_ZN11xercesc_3_210DTDScanner15scanDefaultDeclERNS_9DTDAttDefE:
 1603|  15.0k|{
 1604|  15.0k|    if (fReaderMgr->skippedString(XMLUni::fgRequiredString))
  ------------------
  |  Branch (1604:9): [True: 13.1k, False: 1.91k]
  ------------------
 1605|  13.1k|    {
 1606|  13.1k|        toFill.setDefaultType(XMLAttDef::Required);
 1607|  13.1k|        return;
 1608|  13.1k|    }
 1609|       |
 1610|  1.91k|    if (fReaderMgr->skippedString(XMLUni::fgImpliedString))
  ------------------
  |  Branch (1610:9): [True: 266, False: 1.65k]
  ------------------
 1611|    266|    {
 1612|    266|        toFill.setDefaultType(XMLAttDef::Implied);
 1613|    266|        return;
 1614|    266|    }
 1615|       |
 1616|  1.65k|    if (fReaderMgr->skippedString(XMLUni::fgFixedString))
  ------------------
  |  Branch (1616:9): [True: 1.62k, False: 22]
  ------------------
 1617|  1.62k|    {
 1618|       |        //
 1619|       |        //  There must be space before the fixed value. If there is not, then
 1620|       |        //  emit an error but keep going.
 1621|       |        //
 1622|  1.62k|        if (!fReaderMgr->skippedSpace())
  ------------------
  |  Branch (1622:13): [True: 1, False: 1.62k]
  ------------------
 1623|      1|            fScanner->emitError(XMLErrs::ExpectedWhitespace);
 1624|  1.62k|        else
 1625|  1.62k|            fReaderMgr->skipPastSpaces();
 1626|  1.62k|        toFill.setDefaultType(XMLAttDef::Fixed);
 1627|  1.62k|    }
 1628|     22|     else
 1629|     22|    {
 1630|     22|        toFill.setDefaultType(XMLAttDef::Default);
 1631|     22|    }
 1632|       |
 1633|       |    //
 1634|       |    //  If we got here, its fixed or default, so we need to get a value.
 1635|       |    //  If we don't, then emit an error but just set the default value to
 1636|       |    //  an empty string and try to keep going.
 1637|       |    //
 1638|       |    // Check for PE ref or optional whitespace
 1639|  1.65k|    checkForPERef(false, true);
 1640|       |
 1641|  1.65k|    XMLBufBid bbValue(fBufMgr);
 1642|  1.65k|    if (!scanAttValue(toFill.getFullName(), bbValue.getBuffer(), toFill.getType()))
  ------------------
  |  Branch (1642:9): [True: 27, False: 1.62k]
  ------------------
 1643|     27|        fScanner->emitError(XMLErrs::ExpectedDefAttrDecl);
 1644|       |
 1645|  1.65k|    toFill.setValue(bbValue.getRawBuffer());
 1646|  1.65k|}
_ZN11xercesc_3_210DTDScanner15scanElementDeclEv:
 1655|  4.71k|{
 1656|       |    //
 1657|       |    //  Space is legal (required actually) here so check for a PE ref. If
 1658|       |    //  we don't get our whitespace, then issue and error, but try to keep
 1659|       |    //  going.
 1660|       |    //
 1661|  4.71k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (1661:9): [True: 1, False: 4.71k]
  ------------------
 1662|      1|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 1663|       |
 1664|       |    // Get a buffer for the element name and scan in the name
 1665|  4.71k|    XMLBufBid bbName(fBufMgr);
 1666|  4.71k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (1666:9): [True: 67, False: 4.64k]
  ------------------
 1667|     67|    {
 1668|     67|        fScanner->emitError(XMLErrs::ExpectedElementName);
 1669|     67|        fReaderMgr->skipPastChar(chCloseAngle);
 1670|     67|        return;
 1671|     67|    }
 1672|       |
 1673|       |    // Look this guy up in the element decl pool
 1674|  4.64k|    DTDElementDecl* decl = (DTDElementDecl*) fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, bbName.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
 1675|       |
 1676|       |    //
 1677|       |    //  If it does not exist, then we need to create it. If it does and
 1678|       |    //  its marked as declared, then that's an error, but we still need to
 1679|       |    //  scan over the content model so use the dummy declaration that the
 1680|       |    //  parsing code can fill in.
 1681|       |    //
 1682|  4.64k|    if (decl)
  ------------------
  |  Branch (1682:9): [True: 2.15k, False: 2.49k]
  ------------------
 1683|  2.15k|    {
 1684|  2.15k|        if (decl->isDeclared())
  ------------------
  |  Branch (1684:13): [True: 2.10k, False: 48]
  ------------------
 1685|  2.10k|        {
 1686|  2.10k|            if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (1686:17): [True: 0, False: 2.10k]
  ------------------
 1687|      0|                fScanner->getValidator()->emitError(XMLValid::ElementAlreadyExists, bbName.getRawBuffer());
 1688|       |
 1689|  2.10k|            if (!fDumElemDecl)
  ------------------
  |  Branch (1689:17): [True: 144, False: 1.96k]
  ------------------
 1690|    144|                fDumElemDecl = new (fMemoryManager) DTDElementDecl
 1691|    144|                (
 1692|    144|                    bbName.getRawBuffer()
 1693|    144|                    , fEmptyNamespaceId
 1694|    144|                    , DTDElementDecl::Any
 1695|    144|                    , fMemoryManager
 1696|    144|                );
 1697|  1.96k|            else
 1698|  1.96k|                fDumElemDecl->setElementName(bbName.getRawBuffer(),fEmptyNamespaceId);
 1699|  2.10k|        }
 1700|  2.15k|    }
 1701|  2.49k|     else
 1702|  2.49k|    {
 1703|       |        //
 1704|       |        //  Create the new empty declaration to fill in and put it into
 1705|       |        //  the decl pool.
 1706|       |        //
 1707|  2.49k|        decl = new (fGrammarPoolMemoryManager) DTDElementDecl
 1708|  2.49k|        (
 1709|  2.49k|            bbName.getRawBuffer()
 1710|  2.49k|            , fEmptyNamespaceId
 1711|  2.49k|            , DTDElementDecl::Any
 1712|  2.49k|            , fGrammarPoolMemoryManager
 1713|  2.49k|        );
 1714|  2.49k|        fDTDGrammar->putElemDecl(decl);
 1715|  2.49k|    }
 1716|       |
 1717|       |    // Set a flag for whether we will ignore this one
 1718|  4.64k|    const bool isIgnored = (decl == fDumElemDecl);
 1719|       |
 1720|       |    // Mark this one if being externally declared
 1721|  4.64k|    decl->setExternalElemDeclaration(isReadingExternalEntity());
 1722|       |
 1723|       |    // Mark this one as being declared
 1724|  4.64k|    decl->setCreateReason(XMLElementDecl::Declared);
 1725|       |
 1726|       |    // Another check for a PE ref, with at least required whitespace
 1727|  4.64k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (1727:9): [True: 47, False: 4.60k]
  ------------------
 1728|     47|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 1729|       |
 1730|       |    // And now scan the content model for this guy.
 1731|  4.64k|    if (!scanContentSpec(*decl))
  ------------------
  |  Branch (1731:9): [True: 0, False: 4.64k]
  ------------------
 1732|      0|    {
 1733|      0|        fReaderMgr->skipPastChar(chCloseAngle);
 1734|      0|        return;
 1735|      0|    }
 1736|       |
 1737|       |    // Another check for a PE ref, but we don't require whitespace here
 1738|  4.64k|    checkForPERef(false, true);
 1739|       |
 1740|       |    // And we should have the ending angle bracket
 1741|  4.64k|    if (!fReaderMgr->skippedChar(chCloseAngle))
  ------------------
  |  Branch (1741:9): [True: 17, False: 4.63k]
  ------------------
 1742|     17|    {
 1743|     17|        fScanner->emitError(XMLErrs::UnterminatedElementDecl, bbName.getRawBuffer());
 1744|     17|        fReaderMgr->skipPastChar(chCloseAngle);
 1745|     17|    }
 1746|       |
 1747|       |    //
 1748|       |    //  If we have a DTD handler tell it about the new element decl. We
 1749|       |    //  tell it if its one that can be ignored, cause its an override of a
 1750|       |    //  previously existing decl. If it is being ignored, only call back
 1751|       |    //  if advanced callbacks are enabled.
 1752|       |    //
 1753|  4.64k|    if (fDocTypeHandler)
  ------------------
  |  Branch (1753:9): [True: 0, False: 4.64k]
  ------------------
 1754|      0|        fDocTypeHandler->elementDecl(*decl, isIgnored);
 1755|  4.64k|}
_ZN11xercesc_3_210DTDScanner14scanEntityDeclEv:
 1766|  7.35k|{
 1767|       |    //
 1768|       |    //  Space is required here, but we cannot check for a PE Ref since
 1769|       |    //  there could be a legal (no-ref) percent sign here. Since any
 1770|       |    //  entity that ended here would be illegal, we just skip spaces
 1771|       |    //  and then check for a percent.
 1772|       |    //
 1773|  7.35k|    if (!fReaderMgr->lookingAtSpace())
  ------------------
  |  Branch (1773:9): [True: 1, False: 7.35k]
  ------------------
 1774|      1|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 1775|  7.35k|    else
 1776|  7.35k|        fReaderMgr->skipPastSpaces();
 1777|  7.35k|    bool isPEDecl = fReaderMgr->skippedChar(chPercent);
 1778|       |
 1779|       |    //
 1780|       |    //  If a PE decl, then check if it is followed by a space; if it is so, 
 1781|       |    //  eat the percent and check for spaces or a PE ref on the other side of it. 
 1782|       |    //  Otherwise, it has to be an entity reference for a general entity.
 1783|       |    //
 1784|  7.35k|    if (isPEDecl)
  ------------------
  |  Branch (1784:9): [True: 2.27k, False: 5.08k]
  ------------------
 1785|  2.27k|    {
 1786|  2.27k|        if(!fReaderMgr->getCurrentReader()->isWhitespace(fReaderMgr->peekNextChar()))
  ------------------
  |  Branch (1786:12): [True: 1, False: 2.27k]
  ------------------
 1787|      1|        {
 1788|      1|            isPEDecl=false;
 1789|      2|            while (true)
  ------------------
  |  Branch (1789:20): [Folded - Ignored]
  ------------------
 1790|      1|            {
 1791|      1|               if (!expandPERef(false, false, true, false))
  ------------------
  |  Branch (1791:20): [True: 0, False: 1]
  ------------------
 1792|      0|                  fScanner->emitError(XMLErrs::ExpectedEntityRefName);
 1793|       |               // And skip any more spaces in the expanded value
 1794|      1|               if (fReaderMgr->skippedSpace())
  ------------------
  |  Branch (1794:20): [True: 0, False: 1]
  ------------------
 1795|      0|                  fReaderMgr->skipPastSpaces();
 1796|      1|               if (!fReaderMgr->skippedChar(chPercent))
  ------------------
  |  Branch (1796:20): [True: 0, False: 1]
  ------------------
 1797|      0|                  break;
 1798|      1|            }
 1799|      1|        }
 1800|  2.27k|        else if (!checkForPERef(false, true))
  ------------------
  |  Branch (1800:18): [True: 0, False: 2.27k]
  ------------------
 1801|      0|            fScanner->emitError(XMLErrs::ExpectedWhitespace);
 1802|  2.27k|    }
 1803|       |
 1804|       |    //
 1805|       |    //  Now lets get a name, which should be the name of the entity. We
 1806|       |    //  have to get a buffer for this.
 1807|       |    //
 1808|  7.35k|    XMLBufBid bbName(fBufMgr);
 1809|  7.35k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (1809:9): [True: 121, False: 7.23k]
  ------------------
 1810|    121|    {
 1811|    121|        fScanner->emitError(XMLErrs::ExpectedPEName);
 1812|    121|        fReaderMgr->skipPastChar(chCloseAngle);
 1813|    121|        return;
 1814|    121|    }
 1815|       |
 1816|       |    // If namespaces are enabled, then no colons allowed
 1817|  7.23k|    if (fScanner->getDoNamespaces())
  ------------------
  |  Branch (1817:9): [True: 0, False: 7.23k]
  ------------------
 1818|      0|    {
 1819|      0|        if (XMLString::indexOf(bbName.getRawBuffer(), chColon) != -1)
  ------------------
  |  Branch (1819:13): [True: 0, False: 0]
  ------------------
 1820|      0|            fScanner->emitError(XMLErrs::ColonNotLegalWithNS);
 1821|      0|    }
 1822|       |
 1823|       |    //
 1824|       |    //  See if this entity already exists. If so, then the existing one
 1825|       |    //  takes precendence. So we use the local dummy decl to parse into
 1826|       |    //  and just ignore the results.
 1827|       |    //
 1828|  7.23k|    DTDEntityDecl* entityDecl;
 1829|  7.23k|    if (isPEDecl)
  ------------------
  |  Branch (1829:9): [True: 2.23k, False: 4.99k]
  ------------------
 1830|  2.23k|        entityDecl = fPEntityDeclPool->getByKey(bbName.getRawBuffer());
 1831|  4.99k|    else
 1832|  4.99k|        entityDecl = fDTDGrammar->getEntityDecl(bbName.getRawBuffer());
 1833|       |
 1834|  7.23k|    if (entityDecl)
  ------------------
  |  Branch (1834:9): [True: 4.33k, False: 2.89k]
  ------------------
 1835|  4.33k|    {
 1836|  4.33k|        if (!fDumEntityDecl)
  ------------------
  |  Branch (1836:13): [True: 259, False: 4.08k]
  ------------------
 1837|    259|            fDumEntityDecl = new (fMemoryManager) DTDEntityDecl(fMemoryManager);
 1838|  4.33k|        fDumEntityDecl->setName(bbName.getRawBuffer());
 1839|  4.33k|        entityDecl = fDumEntityDecl;
 1840|  4.33k|    }
 1841|  2.89k|     else
 1842|  2.89k|    {
 1843|       |        // Its not in existence already, then create an entity decl for it
 1844|  2.89k|        entityDecl = new (fGrammarPoolMemoryManager) DTDEntityDecl(bbName.getRawBuffer(), false, fGrammarPoolMemoryManager);
 1845|       |
 1846|       |        //
 1847|       |        //  Set the declaration location. The parameter indicates whether its
 1848|       |        //  declared in the content/internal subset, so we know whether or not
 1849|       |        //  its in the external subset.
 1850|       |        //
 1851|  2.89k|        entityDecl->setDeclaredInIntSubset(fInternalSubset);
 1852|       |
 1853|       |        // Add it to the appropriate entity decl pool
 1854|  2.89k|        if (isPEDecl)
  ------------------
  |  Branch (1854:13): [True: 348, False: 2.55k]
  ------------------
 1855|    348|            fPEntityDeclPool->put(entityDecl);
 1856|  2.55k|         else
 1857|  2.55k|            fDTDGrammar->putEntityDecl(entityDecl);
 1858|  2.89k|    }
 1859|       |
 1860|       |    // Set a flag that indicates whether we are ignoring this one
 1861|  7.23k|    const bool isIgnored = (entityDecl == fDumEntityDecl);
 1862|       |
 1863|       |    // Set the PE flag on it
 1864|  7.23k|    entityDecl->setIsParameter(isPEDecl);
 1865|       |
 1866|       |    //
 1867|       |    //  Space is legal (required actually) here so check for a PE ref. If
 1868|       |    //  we don't get our whitespace, then issue an error, but try to keep
 1869|       |    //  going.
 1870|       |    //
 1871|  7.23k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (1871:9): [True: 18, False: 7.22k]
  ------------------
 1872|     18|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 1873|       |
 1874|       |    // save the hasNoDTD status for Entity Constraint Checking
 1875|  7.23k|    bool hasNoDTD = fScanner->getHasNoDTD();
 1876|  7.23k|    if (hasNoDTD && isPEDecl)
  ------------------
  |  Branch (1876:9): [True: 879, False: 6.35k]
  |  Branch (1876:21): [True: 489, False: 390]
  ------------------
 1877|    489|        fScanner->setHasNoDTD(false);
 1878|       |
 1879|       |    // According to the type call the value scanning method
 1880|  7.23k|    if (!scanEntityDef(*entityDecl, isPEDecl))
  ------------------
  |  Branch (1880:9): [True: 0, False: 7.23k]
  ------------------
 1881|      0|    {
 1882|      0|        fReaderMgr->skipPastChar(chCloseAngle);
 1883|      0|        fScanner->setHasNoDTD(true);
 1884|      0|        fScanner->emitError(XMLErrs::ExpectedEntityValue);
 1885|      0|        return;
 1886|      0|    }
 1887|  7.23k|    if (hasNoDTD)
  ------------------
  |  Branch (1887:9): [True: 857, False: 6.38k]
  ------------------
 1888|    857|        fScanner->setHasNoDTD(true);
 1889|       |
 1890|       |    // Space is legal (but not required) here so check for a PE ref
 1891|  7.23k|    checkForPERef(false, true);
 1892|       |
 1893|       |    // And then we have to have the closing angle bracket
 1894|  7.23k|    if (!fReaderMgr->skippedChar(chCloseAngle))
  ------------------
  |  Branch (1894:9): [True: 49, False: 7.18k]
  ------------------
 1895|     49|    {
 1896|     49|        fScanner->emitError(XMLErrs::UnterminatedEntityDecl, entityDecl->getName());
 1897|     49|        fReaderMgr->skipPastChar(chCloseAngle);
 1898|     49|    }
 1899|       |
 1900|       |    //
 1901|       |    //  If we have a doc type handler, then call it. But only call it for
 1902|       |    //  ignored elements if advanced callbacks are enabled.
 1903|       |    //
 1904|  7.23k|    if (fDocTypeHandler)
  ------------------
  |  Branch (1904:9): [True: 0, False: 7.23k]
  ------------------
 1905|      0|        fDocTypeHandler->entityDecl(*entityDecl, isPEDecl, isIgnored);
 1906|  7.23k|}
_ZN11xercesc_3_210DTDScanner13scanEntityRefERDsS1_Rb:
 1927|  14.6k|{
 1928|       |    // Assume no escape and no second char
 1929|  14.6k|    escaped = false;
 1930|  14.6k|    secondCh = 0;
 1931|       |
 1932|       |    // We have to insure its all done in a single entity
 1933|  14.6k|    const XMLSize_t curReader = fReaderMgr->getCurrentReaderNum();
 1934|       |
 1935|       |    //
 1936|       |    //  If the next char is a pound, then its a character reference and we
 1937|       |    //  need to expand it always.
 1938|       |    //
 1939|  14.6k|    if (fReaderMgr->skippedChar(chPound))
  ------------------
  |  Branch (1939:9): [True: 808, False: 13.7k]
  ------------------
 1940|    808|    {
 1941|       |        //
 1942|       |        //  Its a character reference, so scan it and get back the numeric
 1943|       |        //  value it represents. If it fails, just return immediately.
 1944|       |        //
 1945|    808|        if (!scanCharRef(firstCh, secondCh))
  ------------------
  |  Branch (1945:13): [True: 0, False: 808]
  ------------------
 1946|      0|            return EntityExp_Failed;
 1947|       |
 1948|    808|        if (curReader != fReaderMgr->getCurrentReaderNum())
  ------------------
  |  Branch (1948:13): [True: 0, False: 808]
  ------------------
 1949|      0|            fScanner->emitError(XMLErrs::PartialMarkupInEntity);
 1950|       |
 1951|       |        // Its now escaped since it was a char ref
 1952|    808|        escaped = true;
 1953|    808|        return EntityExp_Returned;
 1954|    808|    }
 1955|       |
 1956|       |    // Get the name of the general entity
 1957|  13.7k|    XMLBufBid bbName(fBufMgr);
 1958|  13.7k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (1958:9): [True: 2, False: 13.7k]
  ------------------
 1959|      2|    {
 1960|      2|        fScanner->emitError(XMLErrs::ExpectedEntityRefName);
 1961|      2|        return EntityExp_Failed;
 1962|      2|    }
 1963|       |
 1964|       |    //
 1965|       |    //  Next char must be a semi-colon. But if its not, just emit
 1966|       |    //  an error and try to continue.
 1967|       |    //
 1968|  13.7k|    if (!fReaderMgr->skippedChar(chSemiColon))
  ------------------
  |  Branch (1968:9): [True: 1, False: 13.7k]
  ------------------
 1969|      1|        fScanner->emitError(XMLErrs::UnterminatedEntityRef, bbName.getRawBuffer());
 1970|       |
 1971|       |    // Make sure it was all in one entity reader
 1972|  13.7k|    if (curReader != fReaderMgr->getCurrentReaderNum())
  ------------------
  |  Branch (1972:9): [True: 0, False: 13.7k]
  ------------------
 1973|      0|        fScanner->emitError(XMLErrs::PartialMarkupInEntity);
 1974|       |
 1975|       |    // Look it up the name the general entity pool
 1976|  13.7k|    XMLEntityDecl* decl = fDTDGrammar->getEntityDecl(bbName.getRawBuffer());
 1977|       |
 1978|       |    // If it does not exist, then obviously an error
 1979|  13.7k|    if (!decl)
  ------------------
  |  Branch (1979:9): [True: 7.06k, False: 6.73k]
  ------------------
 1980|  7.06k|    {
 1981|       |        // XML 1.0 Section 4.1
 1982|  7.06k|        if (fScanner->getStandalone() || fScanner->getHasNoDTD()) {
  ------------------
  |  Branch (1982:13): [True: 20, False: 7.04k]
  |  Branch (1982:42): [True: 1, False: 7.04k]
  ------------------
 1983|     21|            fScanner->emitError(XMLErrs::EntityNotFound, bbName.getRawBuffer());
 1984|     21|        }
 1985|  7.04k|        else {
 1986|  7.04k|            if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (1986:17): [True: 0, False: 7.04k]
  ------------------
 1987|      0|                fScanner->getValidator()->emitError(XMLValid::VC_EntityNotFound, bbName.getRawBuffer());
 1988|  7.04k|        }
 1989|       |
 1990|  7.06k|        return EntityExp_Failed;
 1991|  7.06k|    }
 1992|       |
 1993|       |
 1994|       |    //
 1995|       |    // XML 1.0 Section 4.1
 1996|       |    //  If we are a standalone document, then it has to have been declared
 1997|       |    //  in the internal subset.
 1998|       |    //
 1999|  6.73k|    if (fScanner->getStandalone() && !decl->getDeclaredInIntSubset())
  ------------------
  |  Branch (1999:9): [True: 1.54k, False: 5.18k]
  |  Branch (1999:38): [True: 0, False: 1.54k]
  ------------------
 2000|      0|        fScanner->emitError(XMLErrs::IllegalRefInStandalone, bbName.getRawBuffer());
 2001|       |
 2002|       |    //
 2003|       |    //  If its a special char reference, then its escaped and we can return
 2004|       |    //  it directly.
 2005|       |    //
 2006|  6.73k|    if (decl->getIsSpecialChar())
  ------------------
  |  Branch (2006:9): [True: 549, False: 6.18k]
  ------------------
 2007|    549|    {
 2008|    549|        firstCh = decl->getValue()[0];
 2009|    549|        escaped = true;
 2010|    549|        return EntityExp_Returned;
 2011|    549|    }
 2012|       |
 2013|  6.18k|    if (decl->isExternal())
  ------------------
  |  Branch (2013:9): [True: 3, False: 6.18k]
  ------------------
 2014|      3|    {
 2015|       |        // If its unparsed, then its not valid here
 2016|       |        // XML 1.0 Section 4.4.4 the appearance of a reference to an unparsed entity is forbidden.
 2017|      3|        if (decl->isUnparsed())
  ------------------
  |  Branch (2017:13): [True: 1, False: 2]
  ------------------
 2018|      1|        {
 2019|      1|            fScanner->emitError(XMLErrs::NoUnparsedEntityRefs, bbName.getRawBuffer());
 2020|      1|            return EntityExp_Failed;
 2021|      1|        }
 2022|       |
 2023|       |        // We are in an attribute value, so not valid.
 2024|       |        // XML 1.0 Section 4.4.4 a reference to an external entity in an attribute value is forbidden.
 2025|      2|        fScanner->emitError(XMLErrs::NoExtRefsInAttValue);
 2026|       |
 2027|       |        // And now create a reader to read this entity
 2028|      2|        InputSource* srcUsed;
 2029|      2|        XMLReader* reader = fReaderMgr->createReader
 2030|      2|        (
 2031|      2|            decl->getBaseURI()
 2032|      2|            , decl->getSystemId()
 2033|      2|            , decl->getPublicId()
 2034|      2|            , false
 2035|      2|            , XMLReader::RefFrom_NonLiteral
 2036|      2|            , XMLReader::Type_General
 2037|      2|            , XMLReader::Source_External
 2038|      2|            , srcUsed
 2039|      2|            , fScanner->getCalculateSrcOfs()
 2040|      2|            , fScanner->getLowWaterMark()
 2041|      2|            , fScanner->getDisableDefaultEntityResolution()
 2042|      2|        );
 2043|       |
 2044|       |        // Put a janitor on the source so it gets cleaned up on exit
 2045|      2|        Janitor<InputSource> janSrc(srcUsed);
 2046|       |
 2047|       |        //
 2048|       |        //  If the creation failed then throw an exception
 2049|       |        //
 2050|      2|        if (!reader)
  ------------------
  |  Branch (2050:13): [True: 0, False: 2]
  ------------------
 2051|      0|            ThrowXMLwithMemMgr1(RuntimeException, XMLExcepts::Gen_CouldNotOpenExtEntity, srcUsed ? srcUsed->getSystemId() : decl->getSystemId(), fMemoryManager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |  |  Branch (266:87): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2052|       |
 2053|       |        //
 2054|       |        //  Push the reader. If its a recursive expansion, then emit an error
 2055|       |        //  and return an failure.
 2056|       |        //
 2057|      2|        if (!fReaderMgr->pushReader(reader, decl))
  ------------------
  |  Branch (2057:13): [True: 0, False: 2]
  ------------------
 2058|      0|        {
 2059|      0|            fScanner->emitError(XMLErrs::RecursiveEntity, decl->getName());
 2060|      0|            return EntityExp_Failed;
 2061|      0|        }
 2062|       |
 2063|       |        // If it starts with the XML string, then parse a text decl
 2064|      2|        if (fScanner->checkXMLDecl(true))
  ------------------
  |  Branch (2064:13): [True: 0, False: 2]
  ------------------
 2065|      0|            scanTextDecl();
 2066|      2|    }
 2067|  6.18k|     else
 2068|  6.18k|    {
 2069|       |        //
 2070|       |        //  Create a reader over a memory stream over the entity value
 2071|       |        //  We force it to assume UTF-16 by passing in an encoding
 2072|       |        //  string. This way it won't both trying to predecode the
 2073|       |        //  first line, looking for an XML/TextDecl.
 2074|       |        //
 2075|  6.18k|        XMLReader* valueReader = fReaderMgr->createIntEntReader
 2076|  6.18k|        (
 2077|  6.18k|            decl->getName()
 2078|  6.18k|            , XMLReader::RefFrom_NonLiteral
 2079|  6.18k|            , XMLReader::Type_General
 2080|  6.18k|            , decl->getValue()
 2081|  6.18k|            , decl->getValueLen()
 2082|  6.18k|            , false
 2083|  6.18k|        );
 2084|       |
 2085|       |        //
 2086|       |        //  Trt to push the entity reader onto the reader manager stack,
 2087|       |        //  where it will become the subsequent input. If it fails, that
 2088|       |        //  means the entity is recursive, so issue an error. The reader
 2089|       |        //  will have just been discarded, but we just keep going.
 2090|       |        //
 2091|  6.18k|        if (!fReaderMgr->pushReader(valueReader, decl))
  ------------------
  |  Branch (2091:13): [True: 3, False: 6.17k]
  ------------------
 2092|      3|            fScanner->emitError(XMLErrs::RecursiveEntity, decl->getName());
 2093|  6.18k|    }
 2094|       |
 2095|  6.18k|    return EntityExp_Pushed;
 2096|  6.18k|}
_ZN11xercesc_3_210DTDScanner17scanEntityLiteralERNS_9XMLBufferE:
 2106|  4.58k|{
 2107|  4.58k|    toFill.reset();
 2108|       |
 2109|       |    // Get the next char which must be a single or double quote
 2110|  4.58k|    XMLCh quoteCh;
 2111|  4.58k|    if (!fReaderMgr->skipIfQuote(quoteCh))
  ------------------
  |  Branch (2111:9): [True: 0, False: 4.58k]
  ------------------
 2112|      0|        return false;
 2113|       |
 2114|       |    // Get a buffer for pulling in entity names when we see GE refs
 2115|  4.58k|    XMLBufBid bbName(fBufMgr);
 2116|  4.58k|    XMLBuffer& nameBuf = bbName.getBuffer();
 2117|       |
 2118|       |    // Remember the current reader
 2119|  4.58k|    const XMLSize_t orgReader = fReaderMgr->getCurrentReaderNum();
 2120|       |
 2121|       |    //
 2122|       |    //  Loop until we see the ending quote character, handling any references
 2123|       |    //  in the process.
 2124|       |    //
 2125|  4.58k|    XMLCh   nextCh;
 2126|  4.58k|    XMLCh   secondCh = 0;
 2127|  4.58k|    bool    gotLeadingSurrogate = false;
 2128|  1.82M|    while (true)
  ------------------
  |  Branch (2128:12): [Folded - Ignored]
  ------------------
 2129|  1.82M|    {
 2130|  1.82M|        nextCh = fReaderMgr->getNextChar();
 2131|       |
 2132|       |        //
 2133|       |        //  Watch specifically for EOF and issue a more meaningful error
 2134|       |        //  if that occurs (since an unterminated quoted char can cause
 2135|       |        //  this easily.)
 2136|       |        //
 2137|  1.82M|        if (!nextCh)
  ------------------
  |  Branch (2137:13): [True: 107, False: 1.82M]
  ------------------
 2138|    107|        {
 2139|    107|            fScanner->emitError(XMLErrs::UnterminatedEntityLiteral);
 2140|    107|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|    107|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 2141|    107|        }
 2142|       |
 2143|       |        //
 2144|       |        //  Break out on our terminating quote char when we are back in the
 2145|       |        //  same reader. Otherwise, we might trigger on a nested quote char
 2146|       |        //  in an expanded entity.
 2147|       |        //
 2148|  1.82M|        if ((nextCh == quoteCh)
  ------------------
  |  Branch (2148:13): [True: 4.31k, False: 1.81M]
  ------------------
 2149|  1.82M|        &&  (fReaderMgr->getCurrentReaderNum() == orgReader))
  ------------------
  |  Branch (2149:13): [True: 4.31k, False: 0]
  ------------------
 2150|  4.31k|        {
 2151|  4.31k|            break;
 2152|  4.31k|        }
 2153|       |
 2154|  1.81M|        if (nextCh == chPercent)
  ------------------
  |  Branch (2154:13): [True: 5, False: 1.81M]
  ------------------
 2155|      5|        {
 2156|       |            //
 2157|       |            //  Put the PE's value on the reader stack and then jump back
 2158|       |            //  to the top to start processing it. The parameter indicates
 2159|       |            //  that it should not scan the reference's content as an external
 2160|       |            //  subset.
 2161|       |            //
 2162|      5|            expandPERef(false, true, true);
 2163|      5|            continue;
 2164|      5|        }
 2165|       |
 2166|       |        //
 2167|       |        //  Ok, now that all the other special stuff is checked, we can
 2168|       |        //  look for a general entity. In here, we cannot have a naked &
 2169|       |        //  and will only expand numerical char refs or the intrinsic char
 2170|       |        //  refs. Others will be left alone.
 2171|       |        //
 2172|  1.81M|        if (nextCh == chAmpersand)
  ------------------
  |  Branch (2172:13): [True: 6.10k, False: 1.81M]
  ------------------
 2173|  6.10k|        {
 2174|       |            //
 2175|       |            //  Here, we only expand numeric char refs, but not any general
 2176|       |            //  entities. However, the stupid XML spec requires that we check
 2177|       |            //  and make sure it does refer to a general entity if its not
 2178|       |            //  a char ref (i.e. no naked '&' chars.)
 2179|       |            //
 2180|  6.10k|            if (fReaderMgr->skippedChar(chPound))
  ------------------
  |  Branch (2180:17): [True: 4.01k, False: 2.08k]
  ------------------
 2181|  4.01k|            {
 2182|       |                // If it failed, then just jump back to the top and try to pick up
 2183|  4.01k|                if (!scanCharRef(nextCh, secondCh))
  ------------------
  |  Branch (2183:21): [True: 0, False: 4.01k]
  ------------------
 2184|      0|                {
 2185|      0|                    gotLeadingSurrogate = false;
 2186|      0|                    continue;
 2187|      0|                }
 2188|  4.01k|            }
 2189|  2.08k|             else
 2190|  2.08k|            {
 2191|  2.08k|                if (!fReaderMgr->getName(nameBuf))
  ------------------
  |  Branch (2191:21): [True: 9, False: 2.08k]
  ------------------
 2192|      9|                {
 2193|      9|                    fScanner->emitError(XMLErrs::ExpectedEntityRefName);
 2194|      9|                }
 2195|  2.08k|                 else
 2196|  2.08k|                {
 2197|       |                    //
 2198|       |                    //  Since we are not expanding any of this, we have to
 2199|       |                    //  put the amp and name into the target buffer as data.
 2200|       |                    //
 2201|  2.08k|                    toFill.append(chAmpersand);
 2202|  2.08k|                    toFill.append(nameBuf.getRawBuffer());
 2203|       |
 2204|       |                    // Make sure we skipped a trailing semicolon
 2205|  2.08k|                    if (!fReaderMgr->skippedChar(chSemiColon))
  ------------------
  |  Branch (2205:25): [True: 18, False: 2.06k]
  ------------------
 2206|     18|                    {
 2207|     18|                        fScanner->emitError
 2208|     18|                        (
 2209|     18|                            XMLErrs::UnterminatedEntityRef
 2210|     18|                            , nameBuf.getRawBuffer()
 2211|     18|                        );
 2212|     18|                    }
 2213|       |
 2214|       |                    // And make the new character the semicolon
 2215|  2.08k|                    nextCh = chSemiColon;
 2216|  2.08k|                }
 2217|       |
 2218|       |                // Either way here we reset the surrogate flag
 2219|  2.08k|                gotLeadingSurrogate = false;
 2220|  2.08k|            }
 2221|  6.10k|        }
 2222|  1.81M|        else if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (2222:18): [True: 1.29k, False: 1.81M]
  |  Branch (2222:40): [True: 442, False: 848]
  ------------------
 2223|    442|        {
 2224|    442|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (2224:17): [True: 0, False: 442]
  ------------------
 2225|      0|                fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
 2226|    442|            else
 2227|    442|                gotLeadingSurrogate = true;
 2228|    442|        }
 2229|  1.81M|         else
 2230|  1.81M|        {
 2231|  1.81M|            if (gotLeadingSurrogate)
  ------------------
  |  Branch (2231:17): [True: 442, False: 1.81M]
  ------------------
 2232|    442|            {
 2233|    442|                if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
  ------------------
  |  Branch (2233:21): [True: 0, False: 442]
  |  Branch (2233:42): [True: 0, False: 442]
  ------------------
 2234|      0|                    fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
 2235|    442|            }
 2236|  1.81M|             else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh))
  ------------------
  |  Branch (2236:23): [True: 5, False: 1.81M]
  ------------------
 2237|      5|            {
 2238|      5|                XMLCh tmpBuf[9];
 2239|      5|                XMLString::binToText
 2240|      5|                (
 2241|      5|                    nextCh
 2242|      5|                    , tmpBuf
 2243|      5|                    , 8
 2244|      5|                    , 16
 2245|      5|                    , fMemoryManager
 2246|      5|                );
 2247|      5|                fScanner->emitError(XMLErrs::InvalidCharacter, tmpBuf);
 2248|      5|                fReaderMgr->skipPastChar(quoteCh);
 2249|      5|                return false;
 2250|      5|            }
 2251|  1.81M|            gotLeadingSurrogate = false;
 2252|  1.81M|        }
 2253|       |
 2254|       |        // Looks ok, so add it to the literal
 2255|  1.81M|        toFill.append(nextCh);
 2256|       |
 2257|  1.81M|        if (secondCh)
  ------------------
  |  Branch (2257:13): [True: 618, False: 1.81M]
  ------------------
 2258|    618|        {
 2259|    618|            toFill.append(secondCh);
 2260|    618|            secondCh=0;
 2261|    618|        }
 2262|  1.81M|    }
 2263|       |
 2264|       |    //
 2265|       |    //  If we got here and did not get back to the original reader level,
 2266|       |    //  then we propogated some entity out of the literal, so issue an
 2267|       |    //  error, but don't fail.
 2268|       |    //
 2269|  4.47k|    if (fReaderMgr->getCurrentReaderNum() != orgReader && fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (2269:9): [True: 0, False: 4.47k]
  |  Branch (2269:59): [True: 0, False: 0]
  ------------------
 2270|      0|        fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 2271|       |
 2272|  4.47k|    return true;
 2273|  4.58k|}
_ZN11xercesc_3_210DTDScanner13scanEntityDefERNS_13DTDEntityDeclEb:
 2282|  7.19k|{
 2283|       |    // Its got to be an entity literal
 2284|  7.19k|    if (fReaderMgr->lookingAtChar(chSingleQuote)
  ------------------
  |  Branch (2284:9): [True: 2.87k, False: 4.32k]
  ------------------
 2285|  7.19k|    ||  fReaderMgr->lookingAtChar(chDoubleQuote))
  ------------------
  |  Branch (2285:9): [True: 1.71k, False: 2.61k]
  ------------------
 2286|  4.58k|    {
 2287|       |        // Get a buffer for the literal
 2288|  4.58k|        XMLBufBid bbValue(fBufMgr);
 2289|       |
 2290|  4.58k|        if (!scanEntityLiteral(bbValue.getBuffer()))
  ------------------
  |  Branch (2290:13): [True: 0, False: 4.58k]
  ------------------
 2291|      0|            return false;
 2292|       |
 2293|       |        // Set it on the entity decl
 2294|  4.58k|        decl.setValue(bbValue.getRawBuffer());
 2295|  4.58k|        return true;
 2296|  4.58k|    }
 2297|       |
 2298|       |    //
 2299|       |    //  Its got to be an external entity, so there must be an external id.
 2300|       |    //  Get buffers for them and scan an external id into them.
 2301|       |    //
 2302|  2.61k|    XMLBufBid bbPubId(fBufMgr);
 2303|  2.61k|    XMLBufBid bbSysId(fBufMgr);
 2304|  2.61k|    if (!scanId(bbPubId.getBuffer(), bbSysId.getBuffer(), IDType_External))
  ------------------
  |  Branch (2304:9): [True: 0, False: 2.61k]
  ------------------
 2305|      0|        return false;
 2306|       |
 2307|  2.61k|    decl.setIsExternal(true);
 2308|  2.61k|    ReaderMgr::LastExtEntityInfo lastInfo;
 2309|  2.61k|    fReaderMgr->getLastExtEntityInfo(lastInfo);
 2310|       |
 2311|       |    // Fill in the id fields of the decl with the info we got
 2312|  2.61k|    const XMLCh* publicId = bbPubId.getRawBuffer();
 2313|  2.61k|    const XMLCh* systemId = bbSysId.getRawBuffer();
 2314|  2.61k|    decl.setPublicId((publicId && *publicId) ? publicId : 0);
  ------------------
  |  Branch (2314:23): [True: 2.39k, False: 214]
  |  Branch (2314:35): [True: 1.05k, False: 1.34k]
  ------------------
 2315|  2.61k|    decl.setSystemId((systemId && *systemId) ? systemId : 0);
  ------------------
  |  Branch (2315:23): [True: 2.39k, False: 214]
  |  Branch (2315:35): [True: 2.11k, False: 277]
  ------------------
 2316|  2.61k|    decl.setBaseURI((lastInfo.systemId && *lastInfo.systemId) ? lastInfo.systemId : 0);
  ------------------
  |  Branch (2316:22): [True: 2.39k, False: 214]
  |  Branch (2316:43): [True: 2.39k, False: 0]
  ------------------
 2317|       |
 2318|       |    // If its a PE decl, we are done
 2319|  2.61k|    bool gotSpaces = checkForPERef(false, true);
 2320|  2.61k|    if (isPEDecl)
  ------------------
  |  Branch (2320:9): [True: 954, False: 1.65k]
  ------------------
 2321|    954|    {
 2322|       |        //
 2323|       |        //  Check for a common error here. NDATA is not allowed for PEs
 2324|       |        //  so check for the NDATA string. If found give a nice meaningful
 2325|       |        //  error and continue parsing to eat the NDATA text.
 2326|       |        //
 2327|    954|        if (gotSpaces)
  ------------------
  |  Branch (2327:13): [True: 300, False: 654]
  ------------------
 2328|    300|        {
 2329|    300|            if (fReaderMgr->skippedString(XMLUni::fgNDATAString))
  ------------------
  |  Branch (2329:17): [True: 1, False: 299]
  ------------------
 2330|      1|                fScanner->emitError(XMLErrs::NDATANotValidForPE);
 2331|    300|        }
 2332|    654|         else
 2333|    654|        {
 2334|    654|            return true;
 2335|    654|        }
 2336|    954|    }
 2337|       |
 2338|       |    // If looking at close angle now, we are done
 2339|  1.95k|    if (fReaderMgr->lookingAtChar(chCloseAngle))
  ------------------
  |  Branch (2339:9): [True: 1.29k, False: 664]
  ------------------
 2340|  1.29k|        return true;
 2341|       |
 2342|       |    // Else we had to have seem the whitespace
 2343|    664|    if (!gotSpaces)
  ------------------
  |  Branch (2343:9): [True: 2, False: 662]
  ------------------
 2344|      2|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 2345|       |
 2346|       |    // We now have to see a notation data string
 2347|    664|    if (!fReaderMgr->skippedString(XMLUni::fgNDATAString))
  ------------------
  |  Branch (2347:9): [True: 3, False: 661]
  ------------------
 2348|      3|        fScanner->emitError(XMLErrs::ExpectedNDATA);
 2349|       |
 2350|       |    // Space is required here, but try to go on if not
 2351|    664|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (2351:9): [True: 1, False: 663]
  ------------------
 2352|      1|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 2353|       |
 2354|       |    // Get a name
 2355|    664|    XMLBufBid bbName(fBufMgr);
 2356|    664|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (2356:9): [True: 9, False: 655]
  ------------------
 2357|      9|    {
 2358|      9|        fScanner->emitError(XMLErrs::ExpectedNotationName);
 2359|      9|        return false;
 2360|      9|    }
 2361|       |
 2362|       |    // Set the decl's notation name
 2363|    655|    decl.setNotationName(bbName.getRawBuffer());
 2364|       |
 2365|    655|    return true;
 2366|    664|}
_ZN11xercesc_3_210DTDScanner15scanEnumerationERKNS_9DTDAttDefERNS_9XMLBufferEb:
 2380|     14|{
 2381|       |    // Reset the passed buffer
 2382|     14|    toFill.reset();
 2383|       |
 2384|       |    // Check for PE ref but don't require space
 2385|     14|    checkForPERef(false, true);
 2386|       |
 2387|       |    // If this is a notation, we need an opening paren
 2388|     14|    if (notation)
  ------------------
  |  Branch (2388:9): [True: 1, False: 13]
  ------------------
 2389|      1|    {
 2390|      1|        if (!fReaderMgr->skippedChar(chOpenParen))
  ------------------
  |  Branch (2390:13): [True: 1, False: 0]
  ------------------
 2391|      1|            fScanner->emitError(XMLErrs::ExpectedOpenParen);
 2392|      1|    }
 2393|       |
 2394|       |    // We need a local buffer to use as well
 2395|     14|    XMLBufBid bbTmp(fBufMgr);
 2396|       |
 2397|    111|    while (true)
  ------------------
  |  Branch (2397:12): [Folded - Ignored]
  ------------------
 2398|    108|    {
 2399|       |        // Space is allowed here for either type so check for PE ref
 2400|    108|        checkForPERef(false, true);
 2401|       |
 2402|       |        // And then get either a name or a name token
 2403|    108|        bool success;
 2404|    108|        if (notation)
  ------------------
  |  Branch (2404:13): [True: 0, False: 108]
  ------------------
 2405|      0|            success = fReaderMgr->getName(bbTmp.getBuffer());
 2406|    108|        else
 2407|    108|            success = fReaderMgr->getNameToken(bbTmp.getBuffer());
 2408|       |
 2409|    108|        if (!success)
  ------------------
  |  Branch (2409:13): [True: 2, False: 106]
  ------------------
 2410|      2|        {
 2411|      2|            fScanner->emitError
 2412|      2|            (
 2413|      2|                XMLErrs::ExpectedEnumValue
 2414|      2|                , attDef.getFullName()
 2415|      2|            );
 2416|      2|            return false;
 2417|      2|        }
 2418|       |
 2419|       |        // Append this value to the target value
 2420|    106|        toFill.append(bbTmp.getRawBuffer(), bbTmp.getLen());
 2421|       |
 2422|       |        // Space is allowed here for either type so check for PE ref
 2423|    106|        checkForPERef(false, true);
 2424|       |
 2425|       |        // Check for the terminating paren
 2426|    106|        if (fReaderMgr->skippedChar(chCloseParen))
  ------------------
  |  Branch (2426:13): [True: 6, False: 100]
  ------------------
 2427|      6|            break;
 2428|       |
 2429|       |        // And append a space separator
 2430|    100|        toFill.append(chSpace);
 2431|       |
 2432|       |        // Check for the pipe character separator
 2433|    100|        if (!fReaderMgr->skippedChar(chPipe))
  ------------------
  |  Branch (2433:13): [True: 3, False: 97]
  ------------------
 2434|      3|        {
 2435|      3|            fScanner->emitError(XMLErrs::ExpectedEnumSepOrParen);
 2436|      3|            return false;
 2437|      3|        }
 2438|    100|    }
 2439|      9|    return true;
 2440|     14|}
_ZN11xercesc_3_210DTDScanner6scanIdERNS_9XMLBufferES2_NS0_7IDTypesE:
 2706|  13.4k|{
 2707|       |    // Clean out both return buffers
 2708|  13.4k|    pubIdToFill.reset();
 2709|  13.4k|    sysIdToFill.reset();
 2710|       |
 2711|       |    //
 2712|       |    //  Check first for the system id first. If we find it, and system id
 2713|       |    //  is one of the legal values, then lets try to scan it.
 2714|       |    //
 2715|       |    // 'SYSTEM' S SystemLiteral
 2716|  13.4k|    if (fReaderMgr->skippedString(XMLUni::fgSysIDString))
  ------------------
  |  Branch (2716:9): [True: 9.18k, False: 4.25k]
  ------------------
 2717|  9.18k|    {
 2718|       |        // If they were looking for a public id, then we failed
 2719|  9.18k|        if (whatKind == IDType_Public)
  ------------------
  |  Branch (2719:13): [True: 0, False: 9.18k]
  ------------------
 2720|      0|        {
 2721|      0|            fScanner->emitError(XMLErrs::ExpectedPublicId);
 2722|      0|            return false;
 2723|      0|        }
 2724|       |
 2725|       |        // We must skip spaces
 2726|  9.18k|        bool skippedSomething;
 2727|  9.18k|        fReaderMgr->skipPastSpaces(skippedSomething);
 2728|  9.18k|        if (!skippedSomething)
  ------------------
  |  Branch (2728:13): [True: 1, False: 9.18k]
  ------------------
 2729|      1|        {
 2730|      1|            fScanner->emitError(XMLErrs::ExpectedWhitespace);
 2731|      1|            return false;
 2732|      1|        }
 2733|       |
 2734|       |        // Get the system literal value
 2735|  9.18k|        return scanSystemLiteral(sysIdToFill);
 2736|  9.18k|    }
 2737|       |
 2738|       |    // Now scan for public id
 2739|       |    // 'PUBLIC' S PubidLiteral S SystemLiteral
 2740|       |    //  or
 2741|       |    // 'PUBLIC' S PubidLiteral
 2742|       |
 2743|       |    // If we don't have any public id string => Error
 2744|  4.25k|    if (!fReaderMgr->skippedString(XMLUni::fgPubIDString)) {
  ------------------
  |  Branch (2744:9): [True: 267, False: 3.98k]
  ------------------
 2745|    267|        fScanner->emitError(XMLErrs::ExpectedSystemOrPublicId);
 2746|    267|        return false;
 2747|    267|    }
 2748|       |
 2749|       |    //
 2750|       |    //  So following this we must have whitespace, a public literal, whitespace,
 2751|       |    //  and a system literal.
 2752|       |    //
 2753|  3.98k|    bool skippedSomething;
 2754|  3.98k|    fReaderMgr->skipPastSpaces(skippedSomething);
 2755|  3.98k|    if (!skippedSomething)
  ------------------
  |  Branch (2755:9): [True: 1, False: 3.98k]
  ------------------
 2756|      1|    {
 2757|      1|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 2758|       |
 2759|       |        //
 2760|       |        //  Just in case, if they just forgot the whitespace but the next char
 2761|       |        //  is a single or double quote, then keep going.
 2762|       |        //
 2763|      1|        const XMLCh chPeek = fReaderMgr->peekNextChar();
 2764|      1|        if ((chPeek != chDoubleQuote) && (chPeek != chSingleQuote))
  ------------------
  |  Branch (2764:13): [True: 0, False: 1]
  |  Branch (2764:42): [True: 0, False: 0]
  ------------------
 2765|      0|            return false;
 2766|      1|    }
 2767|       |
 2768|  3.98k|    if (!scanPublicLiteral(pubIdToFill))
  ------------------
  |  Branch (2768:9): [True: 0, False: 3.98k]
  ------------------
 2769|      0|        return false;
 2770|       |
 2771|       |    // If they wanted a public id, then this is all
 2772|  3.98k|    if (whatKind == IDType_Public)
  ------------------
  |  Branch (2772:9): [True: 0, False: 3.98k]
  ------------------
 2773|      0|        return true;
 2774|       |
 2775|       |    // check if there is any space follows
 2776|  3.98k|    bool hasSpace;
 2777|  3.98k|    fReaderMgr->skipPastSpaces(hasSpace);
 2778|       |
 2779|       |    //
 2780|       |    //  In order to recover best here we need to see if
 2781|       |    //  the next thing is a quote or not
 2782|       |    //
 2783|  3.98k|    const XMLCh chPeek = fReaderMgr->peekNextChar();
 2784|  3.98k|    const bool bIsQuote =  ((chPeek == chDoubleQuote)
  ------------------
  |  Branch (2784:29): [True: 780, False: 3.20k]
  ------------------
 2785|  3.98k|                         || (chPeek == chSingleQuote));
  ------------------
  |  Branch (2785:29): [True: 932, False: 2.27k]
  ------------------
 2786|       |
 2787|  3.98k|    if (!hasSpace)
  ------------------
  |  Branch (2787:9): [True: 1.42k, False: 2.55k]
  ------------------
 2788|  1.42k|    {
 2789|  1.42k|        if (whatKind == IDType_External)
  ------------------
  |  Branch (2789:13): [True: 0, False: 1.42k]
  ------------------
 2790|      0|        {
 2791|       |            //
 2792|       |            //  If its an external Id, then we need to see the system id.
 2793|       |            //  So, emit the error. But, if the next char is a quote, don't
 2794|       |            //  give up since its probably going to work. The user just
 2795|       |            //  missed the separating space. Otherwise, fail.
 2796|       |            //
 2797|      0|            fScanner->emitError(XMLErrs::ExpectedWhitespace);
 2798|      0|            if (!bIsQuote)
  ------------------
  |  Branch (2798:17): [True: 0, False: 0]
  ------------------
 2799|      0|                return false;
 2800|      0|        }
 2801|  1.42k|         else
 2802|  1.42k|        {
 2803|       |            //
 2804|       |            //  We can legally return here. But, if the next char is a quote,
 2805|       |            //  then that's probably not what was desired, since its probably
 2806|       |            //  just that space was forgotten and there really is a system
 2807|       |            //  id to follow.
 2808|       |            //
 2809|       |            //  So treat it like missing whitespace if so and keep going.
 2810|       |            //  Else, just return success.
 2811|       |            //
 2812|  1.42k|            if (bIsQuote)
  ------------------
  |  Branch (2812:17): [True: 2, False: 1.42k]
  ------------------
 2813|      2|                fScanner->emitError(XMLErrs::ExpectedWhitespace);
 2814|  1.42k|             else
 2815|  1.42k|                return true;
 2816|  1.42k|        }
 2817|  1.42k|    }
 2818|       |
 2819|  2.56k|    if (bIsQuote) {
  ------------------
  |  Branch (2819:9): [True: 1.57k, False: 983]
  ------------------
 2820|       |        // there is a quote coming, scan the system literal
 2821|  1.57k|        if (!scanSystemLiteral(sysIdToFill))
  ------------------
  |  Branch (2821:13): [True: 0, False: 1.57k]
  ------------------
 2822|      0|            return false;
 2823|  1.57k|    }
 2824|    983|    else {
 2825|       |        // no quote, if expecting exteral id, this is an error
 2826|    983|        if (whatKind == IDType_External)
  ------------------
  |  Branch (2826:13): [True: 1, False: 982]
  ------------------
 2827|      1|            fScanner->emitError(XMLErrs::ExpectedQuotedString);
 2828|    983|    }
 2829|       |
 2830|  2.56k|    return true;
 2831|  2.56k|}
_ZN11xercesc_3_210DTDScanner18scanInternalSubsetEv:
 2937|  8.28k|{
 2938|       |    // Indicate we are in the internal subset now
 2939|  8.28k|    FlagJanitor<bool> janContentFlag(&fInternalSubset, true);
 2940|       |
 2941|       |    // If we have a doc type handler, tell it the internal subset starts
 2942|  8.28k|    if (fDocTypeHandler)
  ------------------
  |  Branch (2942:9): [True: 0, False: 8.28k]
  ------------------
 2943|      0|        fDocTypeHandler->startIntSubset();
 2944|       |
 2945|       |    // Get a buffer for whitespace
 2946|  8.28k|    XMLBufBid bbSpace(fBufMgr);
 2947|       |
 2948|  8.28k|    bool noErrors = true;
 2949|  38.5k|    while (true)
  ------------------
  |  Branch (2949:12): [Folded - Ignored]
  ------------------
 2950|  36.4k|    {
 2951|  36.4k|        const XMLCh nextCh = fReaderMgr->peekNextChar();
 2952|       |
 2953|       |        //
 2954|       |        //  If we get an end of file marker, just unget it and return a
 2955|       |        //  failure status. The caller will then see the end of file and
 2956|       |        //  faill out correctly.
 2957|       |        //
 2958|  36.4k|        if (!nextCh)
  ------------------
  |  Branch (2958:13): [True: 3.60k, False: 32.8k]
  ------------------
 2959|  3.60k|            return false;
 2960|       |
 2961|       |        // Watch for the end of internal subset marker
 2962|  32.8k|        if (nextCh == chCloseSquare)
  ------------------
  |  Branch (2962:13): [True: 2.62k, False: 30.2k]
  ------------------
 2963|  2.62k|        {
 2964|  2.62k|            fReaderMgr->getNextChar();
 2965|  2.62k|            break;
 2966|  2.62k|        }
 2967|       |
 2968|  30.2k|        if (nextCh == chPercent)
  ------------------
  |  Branch (2968:13): [True: 2.11k, False: 28.1k]
  ------------------
 2969|  2.11k|        {
 2970|       |            //
 2971|       |            //  Expand (and scan if external) the reference value. Tell
 2972|       |            //  it to set the reader to cause an end of entity exception
 2973|       |            //  when this reader dies, which is what the scanExtSubset
 2974|       |            //  method wants (who is called to scan this.)
 2975|       |            //
 2976|  2.11k|            fReaderMgr->getNextChar();
 2977|  2.11k|            expandPERef(true, false, false, true);
 2978|  2.11k|        }
 2979|  28.1k|         else if (nextCh == chOpenAngle)
  ------------------
  |  Branch (2979:19): [True: 23.9k, False: 4.16k]
  ------------------
 2980|  23.9k|        {
 2981|       |            // Remember this reader before we start the scan, for checking
 2982|       |            // XML 1.0 P28a Well-formedness constraint: PE Between Declarations
 2983|  23.9k|            const XMLSize_t orgReader = fReaderMgr->getCurrentReaderNum();
 2984|  23.9k|            bool wasInPE = (fReaderMgr->getCurrentReader()->getType() == XMLReader::Type_PE);
 2985|       |
 2986|       |            // And scan this markup
 2987|  23.9k|            fReaderMgr->getNextChar();
 2988|  23.9k|            scanMarkupDecl(false);
 2989|       |
 2990|       |            // If we did not get back to entry level, then partial markup
 2991|  23.9k|            if (fReaderMgr->getCurrentReaderNum() != orgReader) {
  ------------------
  |  Branch (2991:17): [True: 0, False: 23.9k]
  ------------------
 2992|      0|                if (wasInPE)
  ------------------
  |  Branch (2992:21): [True: 0, False: 0]
  ------------------
 2993|      0|                    fScanner->emitError(XMLErrs::PEBetweenDecl);
 2994|      0|                else if (fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (2994:26): [True: 0, False: 0]
  ------------------
 2995|      0|                    fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 2996|      0|            }
 2997|  23.9k|        }
 2998|  4.16k|         else if (fReaderMgr->getCurrentReader()->isWhitespace(nextCh))
  ------------------
  |  Branch (2998:19): [True: 4.10k, False: 65]
  ------------------
 2999|  4.10k|        {
 3000|       |            //
 3001|       |            //  IF we are doing advanced callbacks and have a doc type
 3002|       |            //  handler, then get the whitespace and call the doc type
 3003|       |            //  handler with it. Otherwise, just skip whitespace.
 3004|       |            //
 3005|  4.10k|            if (fDocTypeHandler)
  ------------------
  |  Branch (3005:17): [True: 0, False: 4.10k]
  ------------------
 3006|      0|            {
 3007|      0|                fReaderMgr->getSpaces(bbSpace.getBuffer());
 3008|      0|                fDocTypeHandler->doctypeWhitespace
 3009|      0|                (
 3010|      0|                    bbSpace.getRawBuffer()
 3011|      0|                    , bbSpace.getLen()
 3012|      0|                );
 3013|      0|            }
 3014|  4.10k|             else
 3015|  4.10k|            {
 3016|  4.10k|                fReaderMgr->skipPastSpaces();
 3017|  4.10k|            }
 3018|  4.10k|        }
 3019|     65|         else
 3020|     65|        {
 3021|       |            // Not valid, so emit an error
 3022|     65|            XMLCh tmpBuf[9];
 3023|     65|            XMLString::binToText
 3024|     65|            (
 3025|     65|                fReaderMgr->getNextChar()
 3026|     65|                , tmpBuf
 3027|     65|                , 8
 3028|     65|                , 16
 3029|     65|                , fMemoryManager
 3030|     65|            );
 3031|     65|            fScanner->emitError
 3032|     65|            (
 3033|     65|                XMLErrs::InvalidCharacterInIntSubset
 3034|     65|                , tmpBuf
 3035|     65|            );
 3036|       |
 3037|       |            //
 3038|       |            //  If an '>', then probably an abnormally terminated
 3039|       |            //  internal subset so just return.
 3040|       |            //
 3041|     65|            if (nextCh == chCloseAngle)
  ------------------
  |  Branch (3041:17): [True: 0, False: 65]
  ------------------
 3042|      0|            {
 3043|      0|                noErrors = false;
 3044|      0|                break;
 3045|      0|            }
 3046|       |
 3047|       |            //
 3048|       |            //  Otherwise, try to sync back up by scanning forward for
 3049|       |            //  a reasonable start character.
 3050|       |            //
 3051|     65|            static const XMLCh toSkip[] =
 3052|     65|            {
 3053|     65|                chPercent, chCloseSquare, chOpenAngle, chNull
 3054|     65|            };
 3055|     65|            fReaderMgr->skipUntilInOrWS(toSkip);
 3056|     65|        }
 3057|  30.2k|    }
 3058|       |
 3059|       |    // If we have a doc type handler, tell it the internal subset ends
 3060|  4.67k|    if (fDocTypeHandler)
  ------------------
  |  Branch (3060:9): [True: 0, False: 4.67k]
  ------------------
 3061|      0|        fDocTypeHandler->endIntSubset();
 3062|       |
 3063|  4.67k|    return noErrors;
 3064|  8.28k|}
_ZN11xercesc_3_210DTDScanner14scanMarkupDeclEb:
 3072|  23.9k|{
 3073|       |    //
 3074|       |    //  We only have two valid first characters here. One is a ! which opens
 3075|       |    //  some markup decl. The other is a ?, which could begin either a PI
 3076|       |    //  or a text decl. If parseTextDecl is false, we cannot accept a text
 3077|       |    //  decl.
 3078|       |    //
 3079|  23.9k|    const XMLCh nextCh = fReaderMgr->getNextChar();
 3080|       |
 3081|  23.9k|    if (nextCh == chBang)
  ------------------
  |  Branch (3081:9): [True: 18.5k, False: 5.37k]
  ------------------
 3082|  18.5k|    {
 3083|  18.5k|        if (fReaderMgr->skippedChar(chDash))
  ------------------
  |  Branch (3083:13): [True: 481, False: 18.1k]
  ------------------
 3084|    481|        {
 3085|    481|            if (fReaderMgr->skippedChar(chDash))
  ------------------
  |  Branch (3085:17): [True: 480, False: 1]
  ------------------
 3086|    480|            {
 3087|    480|                scanComment();
 3088|    480|            }
 3089|      1|             else
 3090|      1|            {
 3091|      1|                fScanner->emitError(XMLErrs::CommentsMustStartWith);
 3092|      1|                fReaderMgr->skipPastChar(chCloseAngle);
 3093|      1|            }
 3094|    481|        }
 3095|  18.1k|         else if (fReaderMgr->skippedChar(chOpenSquare))
  ------------------
  |  Branch (3095:19): [True: 197, False: 17.9k]
  ------------------
 3096|    197|        {
 3097|       |            //
 3098|       |            //  Its a conditional section. This is only valid in the external
 3099|       |            //  subset, so issue an error if we aren't there.
 3100|       |            //
 3101|    197|            if (fInternalSubset)
  ------------------
  |  Branch (3101:17): [True: 197, False: 0]
  ------------------
 3102|    197|            {
 3103|    197|                fScanner->emitError(XMLErrs::ConditionalSectInIntSubset);
 3104|    197|                fReaderMgr->skipPastChar(chCloseAngle);
 3105|    197|                return;
 3106|    197|            }
 3107|       |
 3108|       |            // A PE ref can happen here, but space is not required
 3109|      0|            checkForPERef(false, true);
 3110|       |
 3111|      0|            if (fReaderMgr->skippedString(XMLUni::fgIncludeString))
  ------------------
  |  Branch (3111:17): [True: 0, False: 0]
  ------------------
 3112|      0|            {
 3113|      0|                checkForPERef(false, true);
 3114|       |
 3115|       |                // Check for the following open square bracket
 3116|      0|                if (!fReaderMgr->skippedChar(chOpenSquare))
  ------------------
  |  Branch (3116:21): [True: 0, False: 0]
  ------------------
 3117|      0|                    fScanner->emitError(XMLErrs::ExpectedINCLUDEBracket);
 3118|       |
 3119|       |                // Get the reader we started this on
 3120|      0|                const XMLSize_t orgReader = fReaderMgr->getCurrentReaderNum();
 3121|       |
 3122|      0|                checkForPERef(false, true);
 3123|       |
 3124|       |                //
 3125|       |                //  Recurse back to the ext subset call again, telling it its
 3126|       |                //  in an include section.
 3127|       |                //
 3128|      0|                scanExtSubsetDecl(true, false);
 3129|       |
 3130|       |                //
 3131|       |                //  And see if we got back to the same level. If not, then its
 3132|       |                //  a partial markup error.
 3133|       |                //
 3134|      0|                if (fReaderMgr->getCurrentReaderNum() != orgReader && fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (3134:21): [True: 0, False: 0]
  |  Branch (3134:71): [True: 0, False: 0]
  ------------------
 3135|      0|                    fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 3136|       |
 3137|      0|            }
 3138|      0|             else if (fReaderMgr->skippedString(XMLUni::fgIgnoreString))
  ------------------
  |  Branch (3138:23): [True: 0, False: 0]
  ------------------
 3139|      0|            {
 3140|      0|                checkForPERef(false, true);
 3141|       |
 3142|       |                // Check for the following open square bracket
 3143|      0|                if (!fReaderMgr->skippedChar(chOpenSquare))
  ------------------
  |  Branch (3143:21): [True: 0, False: 0]
  ------------------
 3144|      0|                    fScanner->emitError(XMLErrs::ExpectedINCLUDEBracket);
 3145|       |
 3146|       |                // Get the reader we started this on
 3147|      0|                const XMLSize_t orgReader = fReaderMgr->getCurrentReaderNum();
 3148|       |
 3149|       |                // And scan over the ignored part
 3150|      0|                scanIgnoredSection();
 3151|       |
 3152|       |                //
 3153|       |                //  And see if we got back to the same level. If not, then its
 3154|       |                //  a partial markup error.
 3155|       |                //
 3156|      0|                if (fReaderMgr->getCurrentReaderNum() != orgReader && fScanner->getValidationScheme() == XMLScanner::Val_Always)
  ------------------
  |  Branch (3156:21): [True: 0, False: 0]
  |  Branch (3156:71): [True: 0, False: 0]
  ------------------
 3157|      0|                    fScanner->getValidator()->emitError(XMLValid::PartialMarkupInPE);
 3158|       |
 3159|      0|            }
 3160|      0|             else
 3161|      0|            {
 3162|      0|                fScanner->emitError(XMLErrs::ExpectedIncOrIgn);
 3163|      0|                fReaderMgr->skipPastChar(chCloseAngle);
 3164|      0|            }
 3165|      0|        }
 3166|  17.9k|         else if (fReaderMgr->skippedString(XMLUni::fgAttListString))
  ------------------
  |  Branch (3166:19): [True: 2.63k, False: 15.2k]
  ------------------
 3167|  2.63k|        {
 3168|  2.63k|            scanAttListDecl();
 3169|  2.63k|        }
 3170|  15.2k|         else if (fReaderMgr->skippedString(XMLUni::fgElemString))
  ------------------
  |  Branch (3170:19): [True: 4.71k, False: 10.5k]
  ------------------
 3171|  4.71k|        {
 3172|  4.71k|            scanElementDecl();
 3173|  4.71k|        }
 3174|  10.5k|         else if (fReaderMgr->skippedString(XMLUni::fgEntityString))
  ------------------
  |  Branch (3174:19): [True: 7.35k, False: 3.20k]
  ------------------
 3175|  7.35k|        {
 3176|  7.35k|            scanEntityDecl();
 3177|  7.35k|        }
 3178|  3.20k|         else if (fReaderMgr->skippedString(XMLUni::fgNotationString))
  ------------------
  |  Branch (3178:19): [True: 3.20k, False: 3]
  ------------------
 3179|  3.20k|        {
 3180|  3.20k|            scanNotationDecl();
 3181|  3.20k|        }
 3182|      3|         else
 3183|      3|        {
 3184|      3|            fScanner->emitError(XMLErrs::ExpectedMarkupDecl);
 3185|      3|            fReaderMgr->skipPastChar(chCloseAngle);
 3186|      3|        }
 3187|  18.5k|    }
 3188|  5.37k|     else if (nextCh == chQuestion)
  ------------------
  |  Branch (3188:15): [True: 5.35k, False: 20]
  ------------------
 3189|  5.35k|    {
 3190|       |        // It could be a PI or the XML declaration. Check for Decl
 3191|  5.35k|        if (fScanner->checkXMLDecl(false))
  ------------------
  |  Branch (3191:13): [True: 4, False: 5.34k]
  ------------------
 3192|      4|        {
 3193|       |            // If we are not accepting text decls, its an error
 3194|      4|            if (parseTextDecl)
  ------------------
  |  Branch (3194:17): [True: 0, False: 4]
  ------------------
 3195|      0|            {
 3196|      0|                scanTextDecl();
 3197|      0|            }
 3198|      4|             else
 3199|      4|            {
 3200|       |                // Emit the error and skip past this markup
 3201|      4|                fScanner->emitError(XMLErrs::TextDeclNotLegalHere);
 3202|      4|                fReaderMgr->skipPastChar(chCloseAngle);
 3203|      4|            }
 3204|      4|        }
 3205|  5.34k|         else
 3206|  5.34k|        {
 3207|       |            // It has to be a PI
 3208|  5.34k|            scanPI();
 3209|  5.34k|        }
 3210|  5.35k|    }
 3211|     20|     else
 3212|     20|    {
 3213|       |        // Can't be valid so emit error and try to skip past end of this decl
 3214|     20|        fScanner->emitError(XMLErrs::ExpectedMarkupDecl);
 3215|     20|        fReaderMgr->skipPastChar(chCloseAngle);
 3216|     20|    }
 3217|  23.9k|}
_ZN11xercesc_3_210DTDScanner9scanMixedERNS_14DTDElementDeclE:
 3228|    917|{
 3229|       |    //
 3230|       |    //  The terminating star is only required if there is something more
 3231|       |    //  than (PCDATA).
 3232|       |    //
 3233|    917|    bool starRequired = false;
 3234|       |
 3235|       |    // Get a buffer to be used below to get element names
 3236|    917|    XMLBufBid bbName(fBufMgr);
 3237|    917|    XMLBuffer& nameBuf = bbName.getBuffer();
 3238|       |
 3239|       |    //
 3240|       |    //  Create an initial content spec node. Its just a leaf node with a
 3241|       |    //  PCDATA element id. This current node pointer will be pushed down the
 3242|       |    //  tree as we go.
 3243|       |    //
 3244|    917|    ContentSpecNode* curNode = new (fGrammarPoolMemoryManager) ContentSpecNode
 3245|    917|    (
 3246|    917|        new (fGrammarPoolMemoryManager) QName
 3247|    917|        (
 3248|    917|            XMLUni::fgZeroLenString
 3249|    917|            , XMLUni::fgZeroLenString
 3250|    917|            , XMLElementDecl::fgPCDataElemId
 3251|    917|            , fGrammarPoolMemoryManager
 3252|    917|        )
 3253|    917|        , false
 3254|    917|        , fGrammarPoolMemoryManager
 3255|    917|    );
 3256|       |
 3257|       |    //
 3258|       |    //  Set the initial leaf as the temporary head. If we hit the first choice
 3259|       |    //  node, it will be set up here. When done, this is the node that's set
 3260|       |    //  as the content spec for the element.
 3261|       |    //
 3262|    917|    ContentSpecNode* headNode = curNode;
 3263|       |
 3264|       |    // Remember the original node so we can sense the first choice node
 3265|    917|    ContentSpecNode* orgNode = curNode;
 3266|       |
 3267|       |    //
 3268|       |    //  We just loop around, getting the | character at the top and then
 3269|       |    //  looking for the next element name. We keep up with the last node
 3270|       |    //  and add each new one to its right node.
 3271|       |    //
 3272|  50.2k|    while (true)
  ------------------
  |  Branch (3272:12): [Folded - Ignored]
  ------------------
 3273|  50.2k|    {
 3274|       |        //
 3275|       |        //  First of all we check for some grunt work details of skipping
 3276|       |        //  whitespace, expand PE refs, and catching invalid reps.
 3277|       |        //
 3278|  50.2k|        if (fReaderMgr->lookingAtChar(chPercent))
  ------------------
  |  Branch (3278:13): [True: 1, False: 50.2k]
  ------------------
 3279|      1|        {
 3280|       |            // Expand it and continue
 3281|      1|            checkForPERef(false, true);
 3282|      1|        }
 3283|  50.2k|         else if (fReaderMgr->skippedChar(chAsterisk))
  ------------------
  |  Branch (3283:19): [True: 1, False: 50.2k]
  ------------------
 3284|      1|        {
 3285|       |            //
 3286|       |            //  Tell them they can't have reps in mixed model, but eat
 3287|       |            //  it and keep going if we are allowed to.
 3288|       |            //
 3289|      1|            if (fScanner->emitErrorWillThrowException(XMLErrs::NoRepInMixed))
  ------------------
  |  Branch (3289:17): [True: 1, False: 0]
  ------------------
 3290|      1|            {
 3291|      1|                delete headNode;
 3292|      1|            }
 3293|      1|            fScanner->emitError(XMLErrs::NoRepInMixed);
 3294|      1|        }
 3295|  50.2k|         else if (fReaderMgr->skippedSpace())
  ------------------
  |  Branch (3295:19): [True: 467, False: 49.7k]
  ------------------
 3296|    467|        {
 3297|       |            // Spaces are ok at this point, just eat them and continue
 3298|    467|            fReaderMgr->skipPastSpaces();
 3299|    467|        }
 3300|  49.7k|         else
 3301|  49.7k|        {
 3302|  49.7k|            if (!fReaderMgr->skippedChar(chPipe))
  ------------------
  |  Branch (3302:17): [True: 901, False: 48.8k]
  ------------------
 3303|    901|            {
 3304|       |                // Has to be the closing paren now.
 3305|    901|                if (!fReaderMgr->skippedChar(chCloseParen))
  ------------------
  |  Branch (3305:21): [True: 16, False: 885]
  ------------------
 3306|     16|                {
 3307|     16|                    delete headNode;
 3308|     16|                    fScanner->emitError(XMLErrs::UnterminatedContentModel, toFill.getElementName()->getLocalPart());                     
 3309|     16|                    return false;
 3310|     16|                }
 3311|       |
 3312|    885|                bool starSkipped = true;
 3313|    885|                if (!fReaderMgr->skippedChar(chAsterisk)) {
  ------------------
  |  Branch (3313:21): [True: 319, False: 566]
  ------------------
 3314|       |
 3315|    319|                    starSkipped = false;
 3316|       |
 3317|    319|                    if (starRequired)
  ------------------
  |  Branch (3317:25): [True: 2, False: 317]
  ------------------
 3318|      2|                    {
 3319|      2|                        if (fScanner->emitErrorWillThrowException(XMLErrs::ExpectedAsterisk))
  ------------------
  |  Branch (3319:29): [True: 2, False: 0]
  ------------------
 3320|      2|                        {
 3321|      2|                            delete headNode;
 3322|      2|                        }
 3323|      2|                        fScanner->emitError(XMLErrs::ExpectedAsterisk);
 3324|      2|                    }
 3325|    319|                }
 3326|       |
 3327|       |                //
 3328|       |                //  Create a zero or more node and make the original head
 3329|       |                //  node its first child.
 3330|       |                //
 3331|    885|                if (starRequired || starSkipped) {
  ------------------
  |  Branch (3331:21): [True: 568, False: 317]
  |  Branch (3331:37): [True: 0, False: 317]
  ------------------
 3332|    565|                    headNode = new (fGrammarPoolMemoryManager) ContentSpecNode
 3333|    565|                    (
 3334|    565|                        ContentSpecNode::ZeroOrMore
 3335|    565|                        , headNode
 3336|    565|                        , 0
 3337|    565|                        , true
 3338|    565|                        , true
 3339|    565|                        , fGrammarPoolMemoryManager
 3340|    565|                    );
 3341|    565|                }
 3342|       |
 3343|       |                // Store the head node as the content spec of the element.
 3344|    885|                toFill.setContentSpec(headNode);
 3345|    885|                break;
 3346|    901|            }
 3347|       |
 3348|       |            // Its more than just a PCDATA, so an ending star will be required now
 3349|  48.8k|            starRequired = true;
 3350|       |
 3351|       |            // Space is legal here so check for a PE ref, but don't require space
 3352|  48.8k|            checkForPERef(false, true);
 3353|       |
 3354|       |            // Get a name token
 3355|  48.8k|            if (!fReaderMgr->getName(nameBuf))
  ------------------
  |  Branch (3355:17): [True: 3, False: 48.8k]
  ------------------
 3356|      3|            {
 3357|      3|                delete headNode;
 3358|      3|                fScanner->emitError(XMLErrs::ExpectedElementName);
 3359|      3|                return false;
 3360|      3|            }
 3361|       |
 3362|       |            //
 3363|       |            //  Create a leaf node for it. If we can find the element id for
 3364|       |            //  this element, then use it. Else, we have to fault in an element
 3365|       |            //  decl, marked as created because of being in a content model.
 3366|       |            //
 3367|  48.8k|            XMLElementDecl* decl = fDTDGrammar->getElemDecl(fEmptyNamespaceId, 0, nameBuf.getRawBuffer(), Grammar::TOP_LEVEL_SCOPE);
 3368|  48.8k|            if (!decl)
  ------------------
  |  Branch (3368:17): [True: 927, False: 47.9k]
  ------------------
 3369|    927|            {
 3370|    927|                decl = new (fGrammarPoolMemoryManager) DTDElementDecl
 3371|    927|                (
 3372|    927|                    nameBuf.getRawBuffer()
 3373|    927|                    , fEmptyNamespaceId
 3374|    927|                    , DTDElementDecl::Any
 3375|    927|                    , fGrammarPoolMemoryManager
 3376|    927|                );
 3377|    927|                decl->setCreateReason(XMLElementDecl::InContentModel);
 3378|    927|                decl->setExternalElemDeclaration(isReadingExternalEntity());
 3379|    927|                fDTDGrammar->putElemDecl(decl);
 3380|    927|            }
 3381|       |
 3382|       |            //
 3383|       |            //  If the current node is the original node, this is the first choice
 3384|       |            //  node, so create an initial choice node with the current node and
 3385|       |            //  the new element id. Store this as the head node.
 3386|       |            //
 3387|       |            //  Otherwise, we have to steal the right node of the previous choice
 3388|       |            //  and weave in another choice node there, which has the old choice
 3389|       |            //  as its left and the new leaf as its right.
 3390|       |            //
 3391|  48.8k|            if (curNode == orgNode)
  ------------------
  |  Branch (3391:17): [True: 598, False: 48.2k]
  ------------------
 3392|    598|            {
 3393|    598|                curNode = new (fGrammarPoolMemoryManager) ContentSpecNode
 3394|    598|                (
 3395|    598|                    ContentSpecNode::Choice
 3396|    598|                    , curNode
 3397|    598|                    , new (fGrammarPoolMemoryManager) ContentSpecNode
 3398|    598|                      (
 3399|    598|                          decl->getElementName()
 3400|    598|                          , fGrammarPoolMemoryManager
 3401|    598|                      )
 3402|    598|                    , true
 3403|    598|                    , true
 3404|    598|                    , fGrammarPoolMemoryManager
 3405|    598|                );
 3406|       |
 3407|       |                // Remember the top node
 3408|    598|                headNode = curNode;
 3409|    598|            }
 3410|  48.2k|             else
 3411|  48.2k|            {
 3412|  48.2k|                ContentSpecNode* oldRight = curNode->orphanSecond();
 3413|  48.2k|                curNode->setSecond
 3414|  48.2k|                (
 3415|  48.2k|                    new (fGrammarPoolMemoryManager) ContentSpecNode
 3416|  48.2k|                    (
 3417|  48.2k|                        ContentSpecNode::Choice
 3418|  48.2k|                        , oldRight
 3419|  48.2k|                        , new (fGrammarPoolMemoryManager) ContentSpecNode
 3420|  48.2k|                          (
 3421|  48.2k|                              decl->getElementName()
 3422|  48.2k|                              , fGrammarPoolMemoryManager
 3423|  48.2k|                          )
 3424|  48.2k|                        , true
 3425|  48.2k|                        , true
 3426|  48.2k|                        , fGrammarPoolMemoryManager
 3427|  48.2k|                    )
 3428|  48.2k|                );
 3429|       |
 3430|       |                // Make the new right node the current node
 3431|  48.2k|                curNode = curNode->getSecond();
 3432|  48.2k|            }
 3433|  48.8k|        }
 3434|  50.2k|    }
 3435|       |
 3436|    898|    return true;
 3437|    917|}
_ZN11xercesc_3_210DTDScanner16scanNotationDeclEv:
 3446|  3.20k|{
 3447|       |    // Space is required here so check for a PE ref, and require space
 3448|  3.20k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (3448:9): [True: 0, False: 3.20k]
  ------------------
 3449|      0|    {
 3450|      0|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 3451|      0|        fReaderMgr->skipPastChar(chCloseAngle);
 3452|      0|        return;
 3453|      0|    }
 3454|       |
 3455|       |    //
 3456|       |    //  And now we get a name, which is the name of the notation. Get a
 3457|       |    //  buffer for the name.
 3458|       |    //
 3459|  3.20k|    XMLBufBid bbName(fBufMgr);
 3460|  3.20k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (3460:9): [True: 4, False: 3.19k]
  ------------------
 3461|      4|    {
 3462|      4|        fScanner->emitError(XMLErrs::ExpectedNotationName);
 3463|      4|        fReaderMgr->skipPastChar(chCloseAngle);
 3464|      4|        return;
 3465|      4|    }
 3466|       |
 3467|       |    // If namespaces are enabled, then no colons allowed
 3468|  3.19k|    if (fScanner->getDoNamespaces())
  ------------------
  |  Branch (3468:9): [True: 0, False: 3.19k]
  ------------------
 3469|      0|    {
 3470|      0|        if (XMLString::indexOf(bbName.getRawBuffer(), chColon) != -1)
  ------------------
  |  Branch (3470:13): [True: 0, False: 0]
  ------------------
 3471|      0|            fScanner->emitError(XMLErrs::ColonNotLegalWithNS);
 3472|      0|    }
 3473|       |
 3474|       |    // Space is required here so check for a PE ref, and require space
 3475|  3.19k|    if (!checkForPERef(false, true))
  ------------------
  |  Branch (3475:9): [True: 1, False: 3.19k]
  ------------------
 3476|      1|    {
 3477|      1|        fScanner->emitError(XMLErrs::ExpectedWhitespace);
 3478|      1|        fReaderMgr->skipPastChar(chCloseAngle);
 3479|      1|        return;
 3480|      1|    }
 3481|       |
 3482|       |    //
 3483|       |    //  And scan an external or public id. We need buffers to use for both
 3484|       |    //  of these.
 3485|       |    //
 3486|  3.19k|    XMLBufBid bbPubId(fBufMgr);
 3487|  3.19k|    XMLBufBid bbSysId(fBufMgr);
 3488|  3.19k|    if (!scanId(bbPubId.getBuffer(), bbSysId.getBuffer(), IDType_Either))
  ------------------
  |  Branch (3488:9): [True: 0, False: 3.19k]
  ------------------
 3489|      0|    {
 3490|      0|        fReaderMgr->skipPastChar(chCloseAngle);
 3491|      0|        return;
 3492|      0|    }
 3493|       |
 3494|       |    // We can have an optional space or PE ref here
 3495|  3.19k|    checkForPERef(false, true);
 3496|       |
 3497|       |    //
 3498|       |    //  See if it already exists. If so, add it to the notatino decl pool.
 3499|       |    //  Otherwise, if advanced callbacks are on, create a temp one and
 3500|       |    //  call out for that one.
 3501|       |    //
 3502|  3.19k|    XMLNotationDecl* decl = fDTDGrammar->getNotationDecl(bbName.getRawBuffer());
 3503|  3.19k|    bool isIgnoring = (decl != 0);
 3504|  3.19k|    if (isIgnoring)
  ------------------
  |  Branch (3504:9): [True: 1.13k, False: 2.06k]
  ------------------
 3505|  1.13k|    {
 3506|  1.13k|        fScanner->emitError(XMLErrs::NotationAlreadyExists, bbName.getRawBuffer());
 3507|  1.13k|    }
 3508|  2.06k|     else
 3509|  2.06k|    {
 3510|       |        // Fill in a new notation declaration and add it to the pool
 3511|  2.06k|        const XMLCh* publicId = bbPubId.getRawBuffer();
 3512|  2.06k|        const XMLCh* systemId = bbSysId.getRawBuffer();
 3513|  2.06k|        ReaderMgr::LastExtEntityInfo lastInfo;
 3514|  2.06k|        fReaderMgr->getLastExtEntityInfo(lastInfo);
 3515|       |
 3516|  2.06k|        decl = new (fGrammarPoolMemoryManager) XMLNotationDecl
 3517|  2.06k|        (
 3518|  2.06k|            bbName.getRawBuffer()
 3519|  2.06k|            , (publicId && *publicId) ? publicId : 0
  ------------------
  |  Branch (3519:16): [True: 1.86k, False: 201]
  |  Branch (3519:28): [True: 805, False: 1.05k]
  ------------------
 3520|  2.06k|            , (systemId && *systemId) ? systemId : 0
  ------------------
  |  Branch (3520:16): [True: 1.86k, False: 201]
  |  Branch (3520:28): [True: 239, False: 1.62k]
  ------------------
 3521|  2.06k|            , (lastInfo.systemId && *lastInfo.systemId) ? lastInfo.systemId : 0
  ------------------
  |  Branch (3521:16): [True: 1.86k, False: 201]
  |  Branch (3521:37): [True: 1.86k, False: 0]
  ------------------
 3522|  2.06k|            , fGrammarPoolMemoryManager
 3523|  2.06k|        );
 3524|  2.06k|        fDTDGrammar->putNotationDecl(decl);
 3525|  2.06k|    }
 3526|       |
 3527|       |    //
 3528|       |    //  If we have a document type handler, then tell it about this. If we
 3529|       |    //  are ignoring it, only call out if advanced callbacks are enabled.
 3530|       |    //
 3531|  3.19k|    if (fDocTypeHandler)
  ------------------
  |  Branch (3531:9): [True: 0, False: 3.19k]
  ------------------
 3532|      0|    {
 3533|      0|        fDocTypeHandler->notationDecl
 3534|      0|        (
 3535|      0|            *decl
 3536|      0|            , isIgnoring
 3537|      0|        );
 3538|      0|    }
 3539|       |
 3540|       |    // And one more optional space or PE ref
 3541|  3.19k|    checkForPERef(false, true);
 3542|       |
 3543|       |    // And skip the terminating bracket
 3544|  3.19k|    if (!fReaderMgr->skippedChar(chCloseAngle))
  ------------------
  |  Branch (3544:9): [True: 22, False: 3.17k]
  ------------------
 3545|     22|        fScanner->emitError(XMLErrs::UnterminatedNotationDecl);
 3546|  3.19k|}
_ZN11xercesc_3_210DTDScanner6scanPIEv:
 3558|  5.34k|{
 3559|  5.34k|    const XMLCh* namePtr = 0;
 3560|  5.34k|    const XMLCh* targetPtr = 0;
 3561|       |
 3562|       |    //
 3563|       |    //  If there are any spaces here, then warn about it. If we aren't in
 3564|       |    //  'first error' mode, then we'll come back and can easily pick up
 3565|       |    //  again by just skipping them.
 3566|       |    //
 3567|  5.34k|    if (fReaderMgr->lookingAtSpace())
  ------------------
  |  Branch (3567:9): [True: 1, False: 5.34k]
  ------------------
 3568|      1|    {
 3569|      1|        fScanner->emitError(XMLErrs::PINameExpected);
 3570|      1|        fReaderMgr->skipPastSpaces();
 3571|      1|    }
 3572|       |
 3573|       |    // Get a buffer for the PI name and scan it in
 3574|  5.34k|    XMLBufBid bbName(fBufMgr);
 3575|  5.34k|    if (!fReaderMgr->getName(bbName.getBuffer()))
  ------------------
  |  Branch (3575:9): [True: 4, False: 5.33k]
  ------------------
 3576|      4|    {
 3577|      4|        fScanner->emitError(XMLErrs::PINameExpected);
 3578|      4|        fReaderMgr->skipPastChar(chCloseAngle);
 3579|      4|        return;
 3580|      4|    }
 3581|       |
 3582|       |    // Point the name pointer at the raw data
 3583|  5.33k|    namePtr = bbName.getRawBuffer();
 3584|       |
 3585|       |    // See if it issome form of 'xml' and emit a warning
 3586|       |    //if (!XMLString::compareIString(namePtr, XMLUni::fgXMLString))
 3587|  5.33k|    if (bbName.getLen() == 3 &&
  ------------------
  |  Branch (3587:9): [True: 3.20k, False: 2.13k]
  ------------------
 3588|  5.33k|        (((namePtr[0] == chLatin_x) || (namePtr[0] == chLatin_X)) &&
  ------------------
  |  Branch (3588:11): [True: 467, False: 2.73k]
  |  Branch (3588:40): [True: 1.63k, False: 1.10k]
  ------------------
 3589|  3.20k|         ((namePtr[1] == chLatin_m) || (namePtr[1] == chLatin_M)) &&
  ------------------
  |  Branch (3589:11): [True: 385, False: 1.71k]
  |  Branch (3589:40): [True: 1.39k, False: 319]
  ------------------
 3590|  3.20k|         ((namePtr[2] == chLatin_l) || (namePtr[2] == chLatin_L))))       
  ------------------
  |  Branch (3590:11): [True: 2, False: 1.77k]
  |  Branch (3590:40): [True: 1, False: 1.77k]
  ------------------
 3591|      3|        fScanner->emitError(XMLErrs::NoPIStartsWithXML);
 3592|       |
 3593|       |    // If namespaces are enabled, then no colons allowed
 3594|  5.33k|    if (fScanner->getDoNamespaces())
  ------------------
  |  Branch (3594:9): [True: 0, False: 5.33k]
  ------------------
 3595|      0|    {
 3596|      0|        if (XMLString::indexOf(namePtr, chColon) != -1)
  ------------------
  |  Branch (3596:13): [True: 0, False: 0]
  ------------------
 3597|      0|            fScanner->emitError(XMLErrs::ColonNotLegalWithNS);
 3598|      0|    }
 3599|       |
 3600|       |    //
 3601|       |    //  If we don't hit a space next, then the PI has no target. If we do
 3602|       |    //  then get out the target. Get a buffer for it as well
 3603|       |    //
 3604|  5.33k|    XMLBufBid bbTarget(fBufMgr);
 3605|  5.33k|    if (fReaderMgr->skippedSpace())
  ------------------
  |  Branch (3605:9): [True: 2.71k, False: 2.61k]
  ------------------
 3606|  2.71k|    {
 3607|       |        // Skip any leading spaces
 3608|  2.71k|        fReaderMgr->skipPastSpaces();
 3609|       |
 3610|  2.71k|        bool gotLeadingSurrogate = false;
 3611|       |
 3612|       |        // It does have a target, so lets move on to deal with that.
 3613|  3.58M|        while (1)
  ------------------
  |  Branch (3613:16): [Folded - Ignored]
  ------------------
 3614|  3.58M|        {
 3615|  3.58M|            const XMLCh nextCh = fReaderMgr->getNextChar();
 3616|       |
 3617|       |            // Watch for an end of file, which is always bad here
 3618|  3.58M|            if (!nextCh)
  ------------------
  |  Branch (3618:17): [True: 121, False: 3.58M]
  ------------------
 3619|    121|            {
 3620|    121|                fScanner->emitError(XMLErrs::UnterminatedPI);
 3621|    121|                ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|    121|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 3622|    121|            }
 3623|       |
 3624|       |            // Watch for potential terminating character
 3625|  3.58M|            if (nextCh == chQuestion)
  ------------------
  |  Branch (3625:17): [True: 18.5k, False: 3.56M]
  ------------------
 3626|  18.5k|            {
 3627|       |                // It must be followed by '>' to be a termination of the target
 3628|  18.5k|                if (fReaderMgr->skippedChar(chCloseAngle))
  ------------------
  |  Branch (3628:21): [True: 2.57k, False: 16.0k]
  ------------------
 3629|  2.57k|                    break;
 3630|  18.5k|            }
 3631|       |
 3632|       |            // Check for correct surrogate pairs
 3633|  3.57M|            if ((nextCh >= 0xD800) && (nextCh <= 0xDBFF))
  ------------------
  |  Branch (3633:17): [True: 550, False: 3.57M]
  |  Branch (3633:39): [True: 240, False: 310]
  ------------------
 3634|    240|            {
 3635|    240|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (3635:21): [True: 0, False: 240]
  ------------------
 3636|      0|                    fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
 3637|    240|                else
 3638|    240|                    gotLeadingSurrogate = true;
 3639|    240|            }
 3640|  3.57M|             else
 3641|  3.57M|            {
 3642|  3.57M|                if (gotLeadingSurrogate)
  ------------------
  |  Branch (3642:21): [True: 240, False: 3.57M]
  ------------------
 3643|    240|                {
 3644|    240|                    if ((nextCh < 0xDC00) || (nextCh > 0xDFFF))
  ------------------
  |  Branch (3644:25): [True: 0, False: 240]
  |  Branch (3644:46): [True: 0, False: 240]
  ------------------
 3645|      0|                        fScanner->emitError(XMLErrs::Expected2ndSurrogateChar);
 3646|    240|                }
 3647|       |                // Its got to at least be a valid XML character
 3648|  3.57M|                else if (!fReaderMgr->getCurrentReader()->isXMLChar(nextCh)) {
  ------------------
  |  Branch (3648:26): [True: 7, False: 3.57M]
  ------------------
 3649|       |
 3650|      7|                    XMLCh tmpBuf[9];
 3651|      7|                    XMLString::binToText
 3652|      7|                    (
 3653|      7|                        nextCh
 3654|      7|                        , tmpBuf
 3655|      7|                        , 8
 3656|      7|                        , 16
 3657|      7|                        , fMemoryManager
 3658|      7|                    );
 3659|      7|                    fScanner->emitError(XMLErrs::InvalidCharacter, tmpBuf);
 3660|      7|                }
 3661|       |
 3662|  3.57M|                gotLeadingSurrogate = false;
 3663|  3.57M|            }
 3664|  3.57M|            bbTarget.append(nextCh);
 3665|  3.57M|        }
 3666|  2.71k|    }
 3667|  2.61k|     else
 3668|  2.61k|    {
 3669|       |        // No target, but make sure its terminated ok
 3670|  2.61k|        if (!fReaderMgr->skippedChar(chQuestion))
  ------------------
  |  Branch (3670:13): [True: 12, False: 2.60k]
  ------------------
 3671|     12|        {
 3672|     12|            fScanner->emitError(XMLErrs::UnterminatedPI);
 3673|     12|            fReaderMgr->skipPastChar(chCloseAngle);
 3674|     12|            return;
 3675|     12|        }
 3676|       |
 3677|  2.60k|        if (!fReaderMgr->skippedChar(chCloseAngle))
  ------------------
  |  Branch (3677:13): [True: 3, False: 2.60k]
  ------------------
 3678|      3|        {
 3679|      3|            fScanner->emitError(XMLErrs::UnterminatedPI);
 3680|      3|            fReaderMgr->skipPastChar(chCloseAngle);
 3681|      3|            return;
 3682|      3|        }
 3683|  2.60k|    }
 3684|       |
 3685|       |    // Point the target pointer at the raw data
 3686|  5.20k|    targetPtr = bbTarget.getRawBuffer();
 3687|       |
 3688|       |    //
 3689|       |    //  If we have a handler, then call it.
 3690|       |    //
 3691|  5.20k|    if (fDocTypeHandler)
  ------------------
  |  Branch (3691:9): [True: 0, False: 5.20k]
  ------------------
 3692|      0|    {
 3693|      0|        fDocTypeHandler->doctypePI
 3694|      0|        (
 3695|      0|            namePtr
 3696|      0|            , targetPtr
 3697|      0|        );
 3698|      0|    }
 3699|  5.20k|}
_ZN11xercesc_3_210DTDScanner17scanPublicLiteralERNS_9XMLBufferE:
 3708|  3.97k|{
 3709|  3.97k|    toFill.reset();
 3710|       |
 3711|       |    // Get the next char which must be a single or double quote
 3712|  3.97k|    XMLCh quoteCh;
 3713|  3.97k|    if (!fReaderMgr->skipIfQuote(quoteCh)) {
  ------------------
  |  Branch (3713:9): [True: 40, False: 3.93k]
  ------------------
 3714|     40|        fScanner->emitError(XMLErrs::ExpectedQuotedString);
 3715|     40|        return false;
 3716|     40|    }
 3717|       |
 3718|   584k|    while (true)
  ------------------
  |  Branch (3718:12): [Folded - Ignored]
  ------------------
 3719|   584k|    {
 3720|   584k|        const XMLCh nextCh = fReaderMgr->getNextChar();
 3721|       |
 3722|       |        // Watch for EOF
 3723|   584k|        if (!nextCh)
  ------------------
  |  Branch (3723:13): [True: 2, False: 584k]
  ------------------
 3724|      2|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|      2|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 3725|       |
 3726|   584k|        if (nextCh == quoteCh)
  ------------------
  |  Branch (3726:13): [True: 3.85k, False: 580k]
  ------------------
 3727|  3.85k|            break;
 3728|       |
 3729|       |        //
 3730|       |        //  If its not a valid public id char, then report it but keep going
 3731|       |        //  since that's the best recovery scheme.
 3732|       |        //
 3733|   580k|        if (!fReaderMgr->getCurrentReader()->isPublicIdChar(nextCh))
  ------------------
  |  Branch (3733:13): [True: 72, False: 580k]
  ------------------
 3734|     72|        {
 3735|     72|            XMLCh tmpBuf[9];
 3736|     72|            XMLString::binToText
 3737|     72|            (
 3738|     72|                nextCh
 3739|     72|                , tmpBuf
 3740|     72|                , 8
 3741|     72|                , 16
 3742|     72|                , fMemoryManager
 3743|     72|            );
 3744|     72|            fScanner->emitError(XMLErrs::InvalidPublicIdChar, tmpBuf);
 3745|     72|        }
 3746|       |
 3747|   580k|        toFill.append(nextCh);
 3748|   580k|    }
 3749|  3.93k|    return true;
 3750|  3.93k|}
_ZN11xercesc_3_210DTDScanner17scanSystemLiteralERNS_9XMLBufferE:
 3759|  10.7k|{
 3760|  10.7k|    toFill.reset();
 3761|       |
 3762|       |    // Get the next char which must be a single or double quote
 3763|  10.7k|    XMLCh quoteCh;
 3764|  10.7k|    if (!fReaderMgr->skipIfQuote(quoteCh)) {
  ------------------
  |  Branch (3764:9): [True: 1, False: 10.7k]
  ------------------
 3765|      1|        fScanner->emitError(XMLErrs::ExpectedQuotedString);
 3766|      1|        return false;
 3767|      1|    }
 3768|       |
 3769|  10.7k|	XMLCh nextCh;
 3770|       |    // Break out on terminating quote
 3771|  9.25M|    while ((nextCh=fReaderMgr->getNextChar())!=quoteCh)
  ------------------
  |  Branch (3771:12): [True: 9.24M, False: 10.7k]
  ------------------
 3772|  9.24M|    {
 3773|       |        // Watch for EOF
 3774|  9.24M|        if (!nextCh)
  ------------------
  |  Branch (3774:13): [True: 19, False: 9.24M]
  ------------------
 3775|     19|            ThrowXMLwithMemMgr(UnexpectedEOFException, XMLExcepts::Gen_UnexpectedEOF, fMemoryManager);
  ------------------
  |  |  264|     19|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 3776|  9.24M|        toFill.append(nextCh);
 3777|  9.24M|    }
 3778|  10.7k|    return true;
 3779|  10.7k|}
DTDScanner.cpp:_ZN11xercesc_3_2L11makeRepNodeEDsPNS_15ContentSpecNodeEPNS_13MemoryManagerE:
   60|  1.48M|{
   61|  1.48M|    if (testCh == chQuestion)
  ------------------
  |  Branch (61:9): [True: 10.2k, False: 1.47M]
  ------------------
   62|  10.2k|    {
   63|  10.2k|        return new (manager) ContentSpecNode
   64|  10.2k|        (
   65|  10.2k|            ContentSpecNode::ZeroOrOne
   66|  10.2k|            , prevNode
   67|  10.2k|            , 0
   68|  10.2k|            , true
   69|  10.2k|            , true
   70|  10.2k|            , manager
   71|  10.2k|        );
   72|  10.2k|    }
   73|  1.47M|     else if (testCh == chPlus)
  ------------------
  |  Branch (73:15): [True: 7.54k, False: 1.46M]
  ------------------
   74|  7.54k|    {
   75|  7.54k|        return new (manager) ContentSpecNode
   76|  7.54k|        (
   77|  7.54k|            ContentSpecNode::OneOrMore
   78|  7.54k|            , prevNode
   79|  7.54k|            , 0
   80|  7.54k|            , true
   81|  7.54k|            , true
   82|  7.54k|            , manager
   83|  7.54k|        );
   84|  7.54k|    }
   85|  1.46M|     else if (testCh == chAsterisk)
  ------------------
  |  Branch (85:15): [True: 25.0k, False: 1.44M]
  ------------------
   86|  25.0k|    {
   87|  25.0k|        return new (manager) ContentSpecNode
   88|  25.0k|        (
   89|  25.0k|            ContentSpecNode::ZeroOrMore
   90|  25.0k|            , prevNode
   91|  25.0k|            , 0
   92|  25.0k|            , true
   93|  25.0k|            , true
   94|  25.0k|            , manager
   95|  25.0k|        );
   96|  25.0k|    }
   97|       |
   98|       |    // Just return the incoming node
   99|  1.44M|    return prevNode;
  100|  1.48M|}

_ZN11xercesc_3_210DTDScanner23isReadingExternalEntityEv:
  272|  50.0k|inline bool DTDScanner::isReadingExternalEntity() {
  273|  50.0k|    return (fDocTypeReaderId != fReaderMgr->getCurrentReaderNum());
  274|  50.0k|}

_ZN11xercesc_3_212DTDValidatorC2EPNS_16XMLErrorReporterE:
   42|  8.51k|{
   43|  8.51k|    reset();
   44|  8.51k|}
_ZN11xercesc_3_212DTDValidatorD2Ev:
   47|  8.51k|{
   48|  8.51k|}
_ZN11xercesc_3_212DTDValidator12checkContentEPNS_14XMLElementDeclEPPNS_5QNameEmPm:
   58|   269k|{
   59|       |    //
   60|       |    //  Look up the element id in our element decl pool. This will get us
   61|       |    //  the element decl in our own way of looking at them.
   62|       |    //
   63|   269k|    if (!elemDecl)
  ------------------
  |  Branch (63:9): [True: 0, False: 269k]
  ------------------
   64|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Val_InvalidElemId, getScanner()->getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   65|       |
   66|       |    //
   67|       |    //  Get the content spec type of this element. This will tell us what
   68|       |    //  to do to validate it.
   69|       |    //
   70|   269k|    const DTDElementDecl::ModelTypes modelType = ((DTDElementDecl*) elemDecl)->getModelType();
   71|       |
   72|   269k|    if (modelType == DTDElementDecl::Empty)
  ------------------
  |  Branch (72:9): [True: 3.34k, False: 266k]
  ------------------
   73|  3.34k|    {
   74|       |        //
   75|       |        //  We can do this one here. It cannot have any children. If it does
   76|       |        //  we return 0 as the index of the first bad child.
   77|       |        //
   78|  3.34k|        if (childCount)
  ------------------
  |  Branch (78:13): [True: 1.52k, False: 1.82k]
  ------------------
   79|  1.52k|        {
   80|  1.52k|            *indexFailingChild=0;
   81|  1.52k|            return false;
   82|  1.52k|        }
   83|  3.34k|    }
   84|   266k|     else if (modelType == DTDElementDecl::Any)
  ------------------
  |  Branch (84:15): [True: 245k, False: 21.3k]
  ------------------
   85|   245k|    {
   86|       |        // We pass no judgement on this one, anything goes
   87|   245k|    }
   88|  21.3k|     else if ((modelType == DTDElementDecl::Mixed_Simple)
  ------------------
  |  Branch (88:15): [True: 1.61k, False: 19.7k]
  ------------------
   89|  21.3k|          ||  (modelType == DTDElementDecl::Children))
  ------------------
  |  Branch (89:15): [True: 19.7k, False: 0]
  ------------------
   90|  21.3k|    {
   91|       |        // Get the element's content model or fault it in
   92|  21.3k|        const XMLContentModel* elemCM = elemDecl->getContentModel();
   93|       |
   94|       |        // Ask it to validate and return its return
   95|  21.3k|        return elemCM->validateContent(children, childCount, getScanner()->getEmptyNamespaceId(), indexFailingChild, getScanner()->getMemoryManager());
   96|  21.3k|    }
   97|      0|     else
   98|      0|    {
   99|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMType, getScanner()->getMemoryManager());
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  100|      0|    }
  101|       |
  102|       |    // Went ok, so return success
  103|   247k|    return true;
  104|   269k|}
_ZN11xercesc_3_212DTDValidator5resetEv:
  113|  17.0k|{
  114|  17.0k|}
_ZN11xercesc_3_212DTDValidator17validateAttrValueEPKNS_9XMLAttDefEPKDsbPKNS_14XMLElementDeclE:
  129|  53.8k|{
  130|       |    //
  131|       |    //  Get quick refs to lost of of the stuff in the passed objects in
  132|       |    //  order to simplify the code below, which will reference them very
  133|       |    //  often.
  134|       |    //
  135|  53.8k|    const XMLAttDef::AttTypes       type = attDef->getType();
  136|  53.8k|    const XMLAttDef::DefAttTypes    defType = attDef->getDefaultType();
  137|  53.8k|    const XMLCh* const              valueText = attDef->getValue();
  138|  53.8k|    const XMLCh* const              fullName = attDef->getFullName();
  139|  53.8k|    const XMLCh* const              enumList = attDef->getEnumeration();
  140|  53.8k|    const bool                      isExternal = attDef->isExternal();
  141|       |
  142|       |    //
  143|       |    //  If the default type is fixed, then make sure the passed value maps
  144|       |    //  to the fixed value.
  145|       |    //  If during preContentValidation, the value we are validating is the fixed value itself
  146|       |    //  so no need to compare.
  147|       |    //  Only need to do this for regular attribute value validation
  148|       |    //
  149|  53.8k|    if (defType == XMLAttDef::Fixed && !preValidation)
  ------------------
  |  Branch (149:9): [True: 45.6k, False: 8.19k]
  |  Branch (149:40): [True: 45.2k, False: 401]
  ------------------
  150|  45.2k|    {
  151|  45.2k|        if (!XMLString::equals(attrValue, valueText))
  ------------------
  |  Branch (151:13): [True: 977, False: 44.2k]
  ------------------
  152|    977|            emitError(XMLValid::NotSameAsFixedValue, fullName, attrValue, valueText);
  153|  45.2k|    }
  154|       |
  155|       |    //
  156|       |    //  If its a CDATA attribute, then we are done with any DTD level
  157|       |    //  validation else do the rest.
  158|       |    //
  159|  53.8k|    if (type == XMLAttDef::CData)
  ------------------
  |  Branch (159:9): [True: 23.8k, False: 30.0k]
  ------------------
  160|  23.8k|        return;
  161|       |
  162|       |
  163|       |
  164|       |    // An empty string cannot be valid for any of the other types
  165|  30.0k|    if (!attrValue[0])
  ------------------
  |  Branch (165:9): [True: 19.3k, False: 10.6k]
  ------------------
  166|  19.3k|    {
  167|  19.3k|        emitError(XMLValid::InvalidEmptyAttValue, fullName);
  168|  19.3k|        return;
  169|  19.3k|    }
  170|       |
  171|       |    // See whether we are doing multiple values or not
  172|  10.6k|    const bool multipleValues =
  173|  10.6k|    (
  174|  10.6k|        (type == XMLAttDef::IDRefs)
  ------------------
  |  Branch (174:9): [True: 4.24k, False: 6.35k]
  ------------------
  175|  10.6k|        || (type == XMLAttDef::Entities)
  ------------------
  |  Branch (175:12): [True: 2.08k, False: 4.26k]
  ------------------
  176|  10.6k|        || (type == XMLAttDef::NmTokens)
  ------------------
  |  Branch (176:12): [True: 365, False: 3.90k]
  ------------------
  177|  10.6k|        || (type == XMLAttDef::Notation)
  ------------------
  |  Branch (177:12): [True: 0, False: 3.90k]
  ------------------
  178|  10.6k|        || (type == XMLAttDef::Enumeration)
  ------------------
  |  Branch (178:12): [True: 0, False: 3.90k]
  ------------------
  179|  10.6k|    );
  180|       |
  181|       |    // And whether we must check for a first name char
  182|  10.6k|    const bool firstNameChar =
  183|  10.6k|    (
  184|  10.6k|        (type == XMLAttDef::ID)
  ------------------
  |  Branch (184:9): [True: 1.58k, False: 9.02k]
  ------------------
  185|  10.6k|        || (type == XMLAttDef::IDRef)
  ------------------
  |  Branch (185:12): [True: 1.41k, False: 7.60k]
  ------------------
  186|  10.6k|        || (type == XMLAttDef::IDRefs)
  ------------------
  |  Branch (186:12): [True: 4.24k, False: 3.35k]
  ------------------
  187|  10.6k|        || (type == XMLAttDef::Entity)
  ------------------
  |  Branch (187:12): [True: 754, False: 2.60k]
  ------------------
  188|  10.6k|        || (type == XMLAttDef::Entities)
  ------------------
  |  Branch (188:12): [True: 2.08k, False: 512]
  ------------------
  189|  10.6k|        || (type == XMLAttDef::Notation)
  ------------------
  |  Branch (189:12): [True: 0, False: 512]
  ------------------
  190|  10.6k|    );
  191|       |
  192|       |    // Whether it requires ref checking stuff
  193|  10.6k|    const bool isARefType
  194|  10.6k|    (
  195|  10.6k|        (type == XMLAttDef::ID)
  ------------------
  |  Branch (195:9): [True: 1.58k, False: 9.02k]
  ------------------
  196|  10.6k|        || (type == XMLAttDef::IDRef)
  ------------------
  |  Branch (196:12): [True: 1.41k, False: 7.60k]
  ------------------
  197|  10.6k|        || (type == XMLAttDef::IDRefs)
  ------------------
  |  Branch (197:12): [True: 4.24k, False: 3.35k]
  ------------------
  198|  10.6k|    );
  199|       |
  200|       |    // Some trigger flags to avoid issuing redundant errors and whatnot    
  201|  10.6k|    bool alreadyCapped = false;
  202|       |
  203|       |    //
  204|       |    //  Make a copy of the text that we can mangle and get a pointer we can
  205|       |    //  move through the value
  206|       |    //
  207|       |
  208|       |    // Use a stack-based buffer, when possible...
  209|  10.6k|    XMLCh   tempBuffer[100];
  210|       |
  211|  10.6k|    XMLCh* pszTmpVal = 0;
  212|       |
  213|  10.6k|    ArrayJanitor<XMLCh> janTmpVal(0);
  214|       |
  215|  10.6k|    if (XMLString::stringLen(attrValue) < sizeof(tempBuffer) / sizeof(tempBuffer[0]))
  ------------------
  |  Branch (215:9): [True: 10.1k, False: 422]
  ------------------
  216|  10.1k|    {
  217|  10.1k|        XMLString::copyString(tempBuffer, attrValue);
  218|  10.1k|        pszTmpVal = tempBuffer;
  219|  10.1k|    }
  220|    422|    else
  221|    422|    {
  222|    422|        janTmpVal.reset(XMLString::replicate(attrValue, getScanner()->getMemoryManager()), getScanner()->getMemoryManager());
  223|    422|        pszTmpVal = janTmpVal.get();
  224|    422|    }
  225|       |
  226|       |    //  if the type is an enumeration, normalize it, unless standalone = yes is specified
  227|       |    //  "The standalone document declaration MUST have the value "no" if any external markup declarations contain declarations of:
  228|       |    //   - ...
  229|       |    //   - attributes with tokenized types, where the attribute appears in the document with a value such that normalization will 
  230|       |    //     produce a different value from that which would be produced in the absence of the declaration"
  231|  10.6k|    if (multipleValues && (!isExternal || !getScanner()->getStandalone()))
  ------------------
  |  Branch (231:9): [True: 6.70k, False: 3.90k]
  |  Branch (231:28): [True: 6.70k, False: 0]
  |  Branch (231:43): [True: 0, False: 0]
  ------------------
  232|  6.70k|        XMLString::collapseWS(pszTmpVal, getScanner()->getMemoryManager());
  233|       |
  234|  10.6k|    XMLCh* valPtr = pszTmpVal;
  235|       |
  236|  10.6k|    bool doNamespace = getScanner()->getDoNamespaces();
  237|       |
  238|  26.3k|    while (true)
  ------------------
  |  Branch (238:12): [Folded - Ignored]
  ------------------
  239|  26.3k|    {
  240|       |        //
  241|       |        //  Make sure the first character is a valid first name char, i.e.
  242|       |        //  if its a Name value. For NmToken values we don't treat the first
  243|       |        //  char any differently.
  244|       |        //
  245|  26.3k|        if (firstNameChar)
  ------------------
  |  Branch (245:13): [True: 25.7k, False: 518]
  ------------------
  246|  25.7k|        {
  247|       |            // If its not, emit and error but try to keep going
  248|  25.7k|            if (!getReaderMgr()->getCurrentReader()->isFirstNameChar(*valPtr))
  ------------------
  |  Branch (248:17): [True: 13.3k, False: 12.4k]
  ------------------
  249|  13.3k|                emitError(XMLValid::AttrValNotName, valPtr, fullName);
  250|  25.7k|            valPtr++;
  251|  25.7k|        }
  252|       |
  253|       |        // Make sure all the remaining chars are valid name chars
  254|   119k|        while (*valPtr)
  ------------------
  |  Branch (254:16): [True: 112k, False: 7.53k]
  ------------------
  255|   112k|        {
  256|       |            //
  257|       |            //  If we hit a whitespace, its either a break between two
  258|       |            //  or more values, or an error if we have a single value.
  259|       |            //
  260|       |            //
  261|       |            //   XML1.0-3rd
  262|       |            //
  263|       |            //   [6]   Names   ::=   Name (#x20 Name)*
  264|       |            //   [8]   Nmtokens   ::=   Nmtoken (#x20 Nmtoken)*
  265|       |            //
  266|       |            //   only and only ONE #x20 is allowed to be the delimiter
  267|       |            //
  268|   112k|            if (*valPtr==chSpace)
  ------------------
  |  Branch (268:17): [True: 15.9k, False: 96.2k]
  ------------------
  269|  15.9k|            {
  270|  15.9k|                if (!multipleValues)
  ------------------
  |  Branch (270:21): [True: 258, False: 15.7k]
  ------------------
  271|    258|                {
  272|    258|                    emitError(XMLValid::NoMultipleValues, fullName);
  273|    258|                    return;
  274|    258|                }
  275|       |
  276|  15.7k|                break;
  277|  15.9k|            }
  278|       |
  279|       |            // Now this attribute can be of type
  280|       |            //     ID, IDREF, IDREFS, ENTITY, ENTITIES, NOTATION, NMTOKEN, NMTOKENS, ENUMERATION
  281|       |            //  All these must be valid XMLName
  282|       |            // If namespace is enabled, colon is not allowed in the first 6
  283|       |
  284|  96.2k|            if (doNamespace && *valPtr == chColon && firstNameChar)
  ------------------
  |  Branch (284:17): [True: 0, False: 96.2k]
  |  Branch (284:32): [True: 0, False: 0]
  |  Branch (284:54): [True: 0, False: 0]
  ------------------
  285|      0|                emitError(XMLValid::ColonNotValidWithNS);
  286|       |
  287|  96.2k|            if (!getReaderMgr()->getCurrentReader()->isNameChar(*valPtr))
  ------------------
  |  Branch (287:17): [True: 2.81k, False: 93.4k]
  ------------------
  288|  2.81k|            {
  289|  2.81k|                emitError(XMLValid::AttrValNotName, valPtr, fullName);
  290|  2.81k|                return;
  291|  2.81k|            }
  292|  93.4k|            valPtr++;
  293|  93.4k|        }
  294|       |
  295|       |        //
  296|       |        //  Cap it off at the current non-name char. If already capped,
  297|       |        //  then remember this.
  298|       |        //
  299|  23.2k|        if (!(*valPtr))
  ------------------
  |  Branch (299:13): [True: 7.53k, False: 15.7k]
  ------------------
  300|  7.53k|            alreadyCapped = true;
  301|  23.2k|        *valPtr = 0;
  302|       |
  303|       |        //
  304|       |        //  If this type of attribute requires that we track reference
  305|       |        //  stuff, then handle that.
  306|       |        //
  307|  23.2k|        if (isARefType)
  ------------------
  |  Branch (307:13): [True: 17.2k, False: 6.01k]
  ------------------
  308|  17.2k|        {
  309|  17.2k|            if ((type == XMLAttDef::ID)
  ------------------
  |  Branch (309:17): [True: 1.21k, False: 16.0k]
  ------------------
  310|  17.2k|            ||  (type == XMLAttDef::IDRef)
  ------------------
  |  Branch (310:17): [True: 1.13k, False: 14.8k]
  ------------------
  311|  17.2k|            ||  (type == XMLAttDef::IDRefs))
  ------------------
  |  Branch (311:17): [True: 14.8k, False: 0]
  ------------------
  312|  17.2k|            {
  313|  17.2k|                XMLRefInfo* find = getScanner()->getIDRefList()->get(pszTmpVal);
  314|  17.2k|                if (find)
  ------------------
  |  Branch (314:21): [True: 11.8k, False: 5.31k]
  ------------------
  315|  11.8k|                {
  316|  11.8k|                    if (find->getDeclared() && (type == XMLAttDef::ID))
  ------------------
  |  Branch (316:25): [True: 1.33k, False: 10.5k]
  |  Branch (316:48): [True: 1.04k, False: 286]
  ------------------
  317|  1.04k|                        emitError(XMLValid::ReusedIDValue, pszTmpVal);
  318|  11.8k|                }
  319|  5.31k|                 else
  320|  5.31k|                {
  321|  5.31k|                    find = new (getScanner()->getMemoryManager()) XMLRefInfo
  322|  5.31k|                    (
  323|  5.31k|                        pszTmpVal
  324|  5.31k|                        , false
  325|  5.31k|                        , false
  326|  5.31k|                        , getScanner()->getMemoryManager()
  327|  5.31k|                    );
  328|  5.31k|                    getScanner()->getIDRefList()->put((void*)find->getRefName(), find);
  329|  5.31k|                }
  330|       |
  331|       |                //
  332|       |                //  Mark it declared or used, which might be redundant in some cases
  333|       |                //  but not worth checking
  334|       |                //
  335|  17.2k|                if (type == XMLAttDef::ID)
  ------------------
  |  Branch (335:21): [True: 1.21k, False: 16.0k]
  ------------------
  336|  1.21k|                    find->setDeclared(true);
  337|  16.0k|                else {
  338|  16.0k|                    if (!preValidation) {
  ------------------
  |  Branch (338:25): [True: 13.6k, False: 2.36k]
  ------------------
  339|  13.6k|                        find->setUsed(true);
  340|  13.6k|                    }
  341|  16.0k|                }
  342|  17.2k|            }
  343|  17.2k|        }
  344|  6.01k|         else if (!preValidation && ((type == XMLAttDef::Entity) || (type == XMLAttDef::Entities)))
  ------------------
  |  Branch (344:19): [True: 5.52k, False: 490]
  |  Branch (344:38): [True: 704, False: 4.82k]
  |  Branch (344:69): [True: 4.47k, False: 351]
  ------------------
  345|  5.17k|        {
  346|       |            //
  347|       |            //  If its refering to a entity, then look up the name in the
  348|       |            //  general entity pool. If not there, then its an error. If its
  349|       |            //  not an external unparsed entity, then its an error.
  350|       |            //
  351|       |            //  In case of pre-validation, the above errors should be ignored.
  352|       |            //
  353|  5.17k|            const XMLEntityDecl* decl = fDTDGrammar->getEntityDecl(pszTmpVal);
  354|  5.17k|            if (decl)
  ------------------
  |  Branch (354:17): [True: 491, False: 4.68k]
  ------------------
  355|    491|            {
  356|    491|                if (!decl->isUnparsed())
  ------------------
  |  Branch (356:21): [True: 273, False: 218]
  ------------------
  357|    273|                    emitError(XMLValid::BadEntityRefAttr, pszTmpVal, fullName);
  358|    491|            }
  359|  4.68k|             else
  360|  4.68k|            {
  361|  4.68k|                emitError
  362|  4.68k|                (
  363|  4.68k|                    XMLValid::UnknownEntityRefAttr
  364|  4.68k|                    , fullName
  365|  4.68k|                    , pszTmpVal
  366|  4.68k|                );
  367|  4.68k|            }
  368|  5.17k|        }
  369|    841|         else if ((type == XMLAttDef::Notation) || (type == XMLAttDef::Enumeration))
  ------------------
  |  Branch (369:19): [True: 0, False: 841]
  |  Branch (369:52): [True: 0, False: 841]
  ------------------
  370|      0|        {
  371|       |            //
  372|       |            //  Make sure that this value maps to one of the enumeration or
  373|       |            //  notation values in the enumList parameter. We don't have to
  374|       |            //  look it up in the notation pool (if a notation) because we
  375|       |            //  will look up the enumerated values themselves. If they are in
  376|       |            //  the notation pool (after the DTD is parsed), then obviously
  377|       |            //  this value will be legal since it matches one of them.
  378|       |            //
  379|      0|            if (!XMLString::isInList(pszTmpVal, enumList))
  ------------------
  |  Branch (379:17): [True: 0, False: 0]
  ------------------
  380|      0|                emitError(XMLValid::DoesNotMatchEnumList, pszTmpVal, fullName);
  381|      0|        }
  382|       |
  383|       |        // If not doing multiple values, then we are done
  384|  23.2k|        if (!multipleValues)
  ------------------
  |  Branch (384:13): [True: 3.14k, False: 20.0k]
  ------------------
  385|  3.14k|            break;
  386|       |
  387|       |        //
  388|       |        //  If we are at the end, then break out now, else move up to the
  389|       |        //  next char and update the base pointer.
  390|       |        //
  391|  20.0k|        if (alreadyCapped)
  ------------------
  |  Branch (391:13): [True: 4.38k, False: 15.7k]
  ------------------
  392|  4.38k|            break;
  393|       |
  394|  15.7k|        valPtr++;
  395|  15.7k|        pszTmpVal = valPtr;
  396|  15.7k|    }
  397|       |
  398|  10.6k|}
_ZN11xercesc_3_212DTDValidator20preContentValidationEbb:
  405|  4.22k|{
  406|       |    //
  407|       |    //  Lets enumerate all of the elements in the element decl pool
  408|       |    //  and put out an error for any that did not get declared.
  409|       |    //  We also check all of the attributes as well.
  410|       |    //
  411|  4.22k|    NameIdPoolEnumerator<DTDElementDecl> elemEnum = fDTDGrammar->getElemEnumerator();
  412|  4.22k|    fDTDGrammar->setValidated(true);
  413|  42.5k|    while (elemEnum.hasMoreElements())
  ------------------
  |  Branch (413:12): [True: 38.2k, False: 4.22k]
  ------------------
  414|  38.2k|    {
  415|  38.2k|        const DTDElementDecl& curElem = elemEnum.nextElement();
  416|  38.2k|        const DTDElementDecl::CreateReasons reason = curElem.getCreateReason();
  417|       |
  418|       |        //
  419|       |        //  See if this element decl was ever marked as declared. If
  420|       |        //  not, then put out an error. In some cases its just
  421|       |        //  a warning, such as being referenced in a content model.
  422|       |        //
  423|  38.2k|        if (reason != XMLElementDecl::Declared)
  ------------------
  |  Branch (423:13): [True: 36.4k, False: 1.80k]
  ------------------
  424|  36.4k|        {
  425|  36.4k|            if (reason == XMLElementDecl::AttList)
  ------------------
  |  Branch (425:17): [True: 375, False: 36.1k]
  ------------------
  426|    375|            {
  427|    375|                getScanner()->emitError
  428|    375|                (
  429|    375|                    XMLErrs::UndeclaredElemInAttList
  430|    375|                    , curElem.getFullName()
  431|    375|                );
  432|    375|            }
  433|  36.1k|             else if (reason == XMLElementDecl::AsRootElem)
  ------------------
  |  Branch (433:23): [True: 4.21k, False: 31.9k]
  ------------------
  434|  4.21k|            {
  435|       |                // It's ok that the root element is not declared in the DTD
  436|       |                /*
  437|       |                emitError
  438|       |                (
  439|       |                    XMLValid::UndeclaredElemInDocType
  440|       |                    , curElem.getFullName()
  441|       |                );*/
  442|  4.21k|            }
  443|  31.9k|             else if (reason == XMLElementDecl::InContentModel)
  ------------------
  |  Branch (443:23): [True: 31.9k, False: 0]
  ------------------
  444|  31.9k|            {
  445|  31.9k|                getScanner()->emitError
  446|  31.9k|                (
  447|  31.9k|                    XMLErrs::UndeclaredElemInCM
  448|  31.9k|                    , curElem.getFullName()
  449|  31.9k|                );
  450|  31.9k|            }
  451|      0|            else
  452|      0|            {
  453|       |                #if defined(XERCES_DEBUG)
  454|       |                  if(reuseGrammar && reason == XMLElementDecl::JustFaultIn){
  455|       |                  }
  456|       |                  else
  457|       |                      ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::DTD_UnknownCreateReason, getScanner()->getMemoryManager());
  458|       |                #endif
  459|      0|            }
  460|  36.4k|        }
  461|       |
  462|       |        //
  463|       |        //  Check all of the attributes of the current element.
  464|       |        //  We check for:
  465|       |        //
  466|       |        //  1) Multiple ID attributes
  467|       |        //  2) That all of the default values of attributes are
  468|       |        //      valid for their type.
  469|       |        //  3) That for any notation types, that their lists
  470|       |        //      of possible values refer to declared notations.
  471|       |        //
  472|       |        //  4) XML1.0(3rd edition)
  473|       |        //
  474|       |        //     Validity constraint: One Notation Per Element Type
  475|       |        //     An element type MUST NOT have more than one NOTATION attribute specified.
  476|       |        //
  477|       |        //     Validity constraint: No Notation on Empty Element
  478|       |        //     For compatibility, an attribute of type NOTATION MUST NOT be declared on an element declared EMPTY.
  479|       |        //
  480|       |        //     Validity constraint: No Duplicate Tokens
  481|       |        //     The notation names in a single NotationType attribute declaration, as well as 
  482|       |        //     the NmTokens in a single Enumeration attribute declaration, MUST all be distinct.
  483|       |        //
  484|       |
  485|  38.2k|        XMLAttDefList& attDefList = curElem.getAttDefList();
  486|  38.2k|        bool seenId = false;
  487|  38.2k|        bool seenNOTATION = false;
  488|  38.2k|        bool elemEmpty = (curElem.getModelType() == DTDElementDecl::Empty);
  489|       |
  490|  39.9k|        for(XMLSize_t i=0; i<attDefList.getAttDefCount(); i++)
  ------------------
  |  Branch (490:28): [True: 1.75k, False: 38.2k]
  ------------------
  491|  1.75k|        {
  492|  1.75k|            const XMLAttDef& curAttDef = attDefList.getAttDef(i);
  493|       |
  494|  1.75k|            if (curAttDef.getType() == XMLAttDef::ID)
  ------------------
  |  Branch (494:17): [True: 278, False: 1.47k]
  ------------------
  495|    278|            {
  496|    278|                if (seenId)
  ------------------
  |  Branch (496:21): [True: 57, False: 221]
  ------------------
  497|     57|                {
  498|     57|                    emitError
  499|     57|                    (
  500|     57|                        XMLValid::MultipleIdAttrs
  501|     57|                        , curElem.getFullName()
  502|     57|                    );
  503|     57|                    break;
  504|     57|                }
  505|       |
  506|    221|                seenId = true;
  507|    221|            }
  508|  1.47k|             else if (curAttDef.getType() == XMLAttDef::Notation)
  ------------------
  |  Branch (508:23): [True: 0, False: 1.47k]
  ------------------
  509|      0|            {
  510|      0|                if (seenNOTATION)
  ------------------
  |  Branch (510:21): [True: 0, False: 0]
  ------------------
  511|      0|                {
  512|      0|                    emitError
  513|      0|                    (
  514|      0|                        XMLValid::ElemOneNotationAttr
  515|      0|                      , curElem.getFullName()
  516|      0|                    );
  517|       |
  518|      0|                    break;
  519|      0|                }
  520|       |
  521|      0|                seenNOTATION = true;
  522|       |
  523|       |                // no notation attribute on empty element
  524|      0|                if (elemEmpty)
  ------------------
  |  Branch (524:21): [True: 0, False: 0]
  ------------------
  525|      0|                {
  526|      0|                    emitError
  527|      0|                   (
  528|      0|                      XMLValid::EmptyElemNotationAttr
  529|      0|                    , curElem.getFullName()
  530|      0|                    , curAttDef.getFullName()
  531|      0|                    );
  532|       |
  533|      0|                    break;
  534|      0|                }
  535|       |
  536|       |                //go through enumeration list to check
  537|       |                // distinct 
  538|       |                // notation declaration
  539|      0|                if (curAttDef.getEnumeration())
  ------------------
  |  Branch (539:21): [True: 0, False: 0]
  ------------------
  540|      0|                {
  541|      0|                    checkTokenList(curAttDef, true);
  542|      0|                }
  543|      0|             }
  544|  1.47k|             else if (curAttDef.getType() == XMLAttDef::Enumeration )
  ------------------
  |  Branch (544:23): [True: 0, False: 1.47k]
  ------------------
  545|      0|             {
  546|       |                //go through enumeration list to check
  547|       |                // distinct only
  548|      0|                if (curAttDef.getEnumeration())
  ------------------
  |  Branch (548:21): [True: 0, False: 0]
  ------------------
  549|      0|                {
  550|      0|                    checkTokenList(curAttDef, false);
  551|      0|                }
  552|      0|             }
  553|       |
  554|       |            // If it has a default/fixed value, then validate it
  555|  1.69k|            if (validateDefAttr && curAttDef.getValue())
  ------------------
  |  Branch (555:17): [True: 1.69k, False: 0]
  |  Branch (555:36): [True: 401, False: 1.29k]
  ------------------
  556|    401|            {
  557|    401|                validateAttrValue
  558|    401|                (
  559|    401|                    &curAttDef
  560|    401|                    , curAttDef.getValue()
  561|    401|                    , true
  562|    401|                    , &curElem
  563|    401|                );
  564|    401|            }
  565|  1.69k|        }
  566|  38.2k|    }
  567|       |
  568|       |    //
  569|       |    //  And enumerate all of the general entities. If any of them
  570|       |    //  reference a notation, then make sure the notation exists.
  571|       |    //
  572|  4.22k|    NameIdPoolEnumerator<DTDEntityDecl> entEnum = fDTDGrammar->getEntityEnumerator();
  573|  5.69k|    while (entEnum.hasMoreElements())
  ------------------
  |  Branch (573:12): [True: 1.46k, False: 4.22k]
  ------------------
  574|  1.46k|    {
  575|  1.46k|        const DTDEntityDecl& curEntity = entEnum.nextElement();
  576|       |
  577|  1.46k|        if (!curEntity.getNotationName())
  ------------------
  |  Branch (577:13): [True: 1.42k, False: 48]
  ------------------
  578|  1.42k|            continue;
  579|       |
  580|       |        // It has a notation name, so look it up
  581|     48|        if (!fDTDGrammar->getNotationDecl(curEntity.getNotationName()))
  ------------------
  |  Branch (581:13): [True: 38, False: 10]
  ------------------
  582|     38|        {
  583|     38|            emitError
  584|     38|            (
  585|     38|                XMLValid::NotationNotDeclared
  586|     38|                , curEntity.getNotationName()
  587|     38|            );
  588|     38|        }
  589|     48|    }
  590|  4.22k|}

_ZN11xercesc_3_212DTDValidator10setGrammarEPNS_7GrammarE:
  130|  16.8k|inline void DTDValidator::setGrammar(Grammar* aGrammar) {
  131|  16.8k|    fDTDGrammar = (DTDGrammar*) aGrammar;
  132|  16.8k|}
_ZN11xercesc_3_212DTDValidator15validateElementEPKNS_14XMLElementDeclE:
  134|   558k|inline void DTDValidator::validateElement (const   XMLElementDecl*) {
  135|       |    // no special DTD Element validation
  136|   558k|}
_ZNK11xercesc_3_212DTDValidator10handlesDTDEv:
  142|  8.31k|{
  143|       |    // We definitely want to handle DTD scanning
  144|  8.31k|    return true;
  145|  8.31k|}

_ZN11xercesc_3_214DocTypeHandlerC2Ev:
   45|  8.51k|    {
   46|  8.51k|    }
_ZN11xercesc_3_214DocTypeHandlerD2Ev:
   49|  8.51k|    {
   50|  8.51k|    }

_ZN11xercesc_3_221XMLDTDDescriptionImplC2EPKDsPNS_13MemoryManagerE:
   38|  17.0k|{
   39|  17.0k|    if (systemId)
  ------------------
  |  Branch (39:9): [True: 17.0k, False: 0]
  ------------------
   40|  17.0k|        fSystemId = XMLString::replicate(systemId, memMgr);
   41|  17.0k|}
_ZN11xercesc_3_221XMLDTDDescriptionImplD2Ev:
   44|  17.0k|{
   45|  17.0k|    if (fSystemId)
  ------------------
  |  Branch (45:9): [True: 17.0k, False: 0]
  ------------------
   46|  17.0k|        XMLGrammarDescription::getMemoryManager()->deallocate((void*)fSystemId);
   47|       |
   48|  17.0k|    if (fRootName)
  ------------------
  |  Branch (48:9): [True: 0, False: 17.0k]
  ------------------
   49|      0|        XMLGrammarDescription::getMemoryManager()->deallocate((void*)fRootName);
   50|  17.0k|}
_ZNK11xercesc_3_221XMLDTDDescriptionImpl13getGrammarKeyEv:
   53|  17.0k|{
   54|  17.0k|    return getSystemId();
   55|  17.0k|}
_ZNK11xercesc_3_221XMLDTDDescriptionImpl11getSystemIdEv:
   63|  17.0k|{ 
   64|  17.0k|    return fSystemId; 
   65|  17.0k|}

_ZN11xercesc_3_210CMBinaryOpC2ENS_15ContentSpecNode9NodeTypesEPNS_6CMNodeES4_jPNS_13MemoryManagerE:
   45|  1.32M|{
   46|       |    // Insure that its one of the types we require
   47|  1.32M|    if (((type & 0x0f) != ContentSpecNode::Choice)
  ------------------
  |  Branch (47:9): [True: 75.7k, False: 1.24M]
  ------------------
   48|  1.32M|    &&  ((type & 0x0f) != ContentSpecNode::Sequence))
  ------------------
  |  Branch (48:9): [True: 0, False: 75.7k]
  ------------------
   49|      0|    {
   50|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_BinOpHadUnaryType, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   51|      0|    }
   52|       |    //
   53|       |    //  If its an alternation, then if either child is nullable then
   54|       |    //  this node is nullable. If its a concatenation, then both of
   55|       |    //  them have to be nullable.
   56|       |    //
   57|  1.32M|    if ((type & 0x0f) == ContentSpecNode::Choice)
  ------------------
  |  Branch (57:9): [True: 1.24M, False: 75.7k]
  ------------------
   58|  1.24M|        fIsNullable=(fLeftChild->isNullable() || fRightChild->isNullable());
  ------------------
  |  Branch (58:22): [True: 4.19k, False: 1.24M]
  |  Branch (58:50): [True: 708k, False: 533k]
  ------------------
   59|  75.7k|    else
   60|  75.7k|        fIsNullable=(fLeftChild->isNullable() && fRightChild->isNullable());
  ------------------
  |  Branch (60:22): [True: 23.5k, False: 52.1k]
  |  Branch (60:50): [True: 913, False: 22.6k]
  ------------------
   61|  1.32M|}
_ZN11xercesc_3_210CMBinaryOpD2Ev:
   64|  1.32M|{
   65|  1.32M|    delete fLeftChild;
   66|  1.32M|    delete fRightChild;
   67|  1.32M|}
_ZN11xercesc_3_210CMBinaryOp11orphanChildEv:
   98|  1.32M|{
   99|  1.32M|    delete fLeftChild;
  100|  1.32M|    fLeftChild=0;
  101|  1.32M|    delete fRightChild;
  102|  1.32M|    fRightChild=0;
  103|  1.32M|}
_ZNK11xercesc_3_210CMBinaryOp12calcFirstPosERNS_10CMStateSetE:
  109|  1.32M|{
  110|  1.32M|    if ((getType() & 0x0f) == ContentSpecNode::Choice)
  ------------------
  |  Branch (110:9): [True: 1.24M, False: 75.7k]
  ------------------
  111|  1.24M|    {
  112|       |        // Its the the union of the first positions of our children.
  113|  1.24M|        toSet = fLeftChild->getFirstPos();
  114|  1.24M|        toSet |= fRightChild->getFirstPos();
  115|  1.24M|    }
  116|  75.7k|    else if ((getType() & 0x0f) == ContentSpecNode::Sequence)
  ------------------
  |  Branch (116:14): [True: 75.7k, False: 0]
  ------------------
  117|  75.7k|    {
  118|       |        //
  119|       |        //  If our left child is nullable, then its the union of our
  120|       |        //  children's first positions. Else is our left child's first
  121|       |        //  positions.
  122|       |        //
  123|  75.7k|        toSet = fLeftChild->getFirstPos();
  124|  75.7k|        if (fLeftChild->isNullable())
  ------------------
  |  Branch (124:13): [True: 23.5k, False: 52.1k]
  ------------------
  125|  23.5k|            toSet |= fRightChild->getFirstPos();
  126|  75.7k|    }
  127|  1.32M|}
_ZNK11xercesc_3_210CMBinaryOp11calcLastPosERNS_10CMStateSetE:
  130|  1.32M|{
  131|  1.32M|    if ((getType() & 0x0f) == ContentSpecNode::Choice)
  ------------------
  |  Branch (131:9): [True: 1.24M, False: 74.6k]
  ------------------
  132|  1.24M|    {
  133|       |        // Its the the union of the first positions of our children.
  134|  1.24M|        toSet = fLeftChild->getLastPos();
  135|  1.24M|        toSet |= fRightChild->getLastPos();
  136|  1.24M|    }
  137|  74.6k|    else if ((getType() & 0x0f) == ContentSpecNode::Sequence)
  ------------------
  |  Branch (137:14): [True: 74.6k, False: 0]
  ------------------
  138|  74.6k|    {
  139|       |        //
  140|       |        //  If our right child is nullable, then its the union of our
  141|       |        //  children's last positions. Else is our right child's last
  142|       |        //  positions.
  143|       |        //
  144|  74.6k|        toSet = fRightChild->getLastPos();
  145|  74.6k|        if (fRightChild->isNullable())
  ------------------
  |  Branch (145:13): [True: 1.36k, False: 73.2k]
  ------------------
  146|  1.36k|            toSet |= fLeftChild->getLastPos();
  147|  74.6k|    }
  148|  1.32M|}

_ZN11xercesc_3_26CMLeafD2Ev:
  177|  2.64M|{
  178|  2.64M|    if (fAdopt)
  ------------------
  |  Branch (178:9): [True: 1.09k, False: 2.64M]
  ------------------
  179|  1.09k|        delete fElement;
  180|  2.64M|}
_ZN11xercesc_3_26CMLeafC2EPNS_5QNameEjbjPNS_13MemoryManagerE:
  155|  1.09k|{
  156|  1.09k|    if (!element)
  ------------------
  |  Branch (156:9): [True: 0, False: 1.09k]
  ------------------
  157|      0|    {
  158|      0|        fElement = new (fMemoryManager) QName
  159|      0|        (
  160|      0|              XMLUni::fgZeroLenString
  161|      0|            , XMLUni::fgZeroLenString
  162|      0|            , XMLElementDecl::fgInvalidElemId
  163|      0|            , fMemoryManager
  164|      0|        );
  165|       |        // We have to be responsible for this QName - override adopt parameter
  166|      0|        fAdopt = true;
  167|      0|    }
  168|  1.09k|    else
  169|  1.09k|    {
  170|  1.09k|        fElement = element;
  171|  1.09k|    }
  172|       |    // Leaf nodes are never nullable unless its an epsilon node
  173|  1.09k|    fIsNullable=(fPosition == epsilonNode);
  174|  1.09k|}
_ZN11xercesc_3_26CMLeaf10getElementEv:
  187|   125M|{
  188|   125M|    return fElement;
  189|   125M|}
_ZNK11xercesc_3_26CMLeaf11getPositionEv:
  197|  1.09k|{
  198|  1.09k|    return fPosition;
  199|  1.09k|}
_ZN11xercesc_3_26CMLeafC2EPNS_5QNameEjjPNS_13MemoryManagerE:
  125|  2.64M|{
  126|  2.64M|    if (!element)
  ------------------
  |  Branch (126:9): [True: 0, False: 2.64M]
  ------------------
  127|      0|    {
  128|      0|        fElement = new (fMemoryManager) QName
  129|      0|        (
  130|      0|              XMLUni::fgZeroLenString
  131|      0|            , XMLUni::fgZeroLenString
  132|      0|            , XMLElementDecl::fgInvalidElemId
  133|      0|            , fMemoryManager
  134|      0|        );
  135|       |        // We have to be responsible for this QName - override default fAdopt
  136|      0|        fAdopt = true;
  137|      0|    }
  138|  2.64M|    else
  139|  2.64M|    {
  140|  2.64M|        fElement = element;
  141|  2.64M|    }
  142|       |    // Leaf nodes are never nullable unless its an epsilon node
  143|  2.64M|    fIsNullable=(fPosition == epsilonNode);
  144|  2.64M|}
_ZN11xercesc_3_26CMLeaf11orphanChildEv:
  219|  1.32M|{
  220|  1.32M|}
_ZNK11xercesc_3_26CMLeaf12calcFirstPosERNS_10CMStateSetE:
  226|  1.32M|{
  227|       |    // If we are an epsilon node, then the first pos is an empty set
  228|  1.32M|    if (isNullable())
  ------------------
  |  Branch (228:9): [True: 0, False: 1.32M]
  ------------------
  229|      0|    {
  230|      0|        toSet.zeroBits();
  231|      0|        return;
  232|      0|    }
  233|       |
  234|       |    // Otherwise, its just the one bit of our position
  235|  1.32M|    toSet.setBit(fPosition);
  236|  1.32M|}
_ZNK11xercesc_3_26CMLeaf11calcLastPosERNS_10CMStateSetE:
  239|  1.32M|{
  240|       |    // If we are an epsilon node, then the last pos is an empty set
  241|  1.32M|    if (isNullable())
  ------------------
  |  Branch (241:9): [True: 0, False: 1.32M]
  ------------------
  242|      0|    {
  243|      0|        toSet.zeroBits();
  244|      0|        return;
  245|      0|    }
  246|       |
  247|       |    // Otherwise, its just the one bit of our position
  248|  1.32M|    toSet.setBit(fPosition);
  249|  1.32M|}
_ZNK11xercesc_3_26CMLeaf16isRepeatableLeafEv:
  202|  31.3k|{
  203|  31.3k|    return false;
  204|  31.3k|}

_ZN11xercesc_3_26CMNodeD2Ev:
  143|  4.00M|{
  144|       |    // Clean up any position sets that got created
  145|  4.00M|    delete fFirstPos;
  146|  4.00M|    delete fLastPos;
  147|  4.00M|}
_ZNK11xercesc_3_26CMNode10isNullableEv:
  187|  5.39M|{
  188|  5.39M|    return fIsNullable;
  189|  5.39M|}
_ZN11xercesc_3_26CMNodeC2ENS_15ContentSpecNode9NodeTypesEjPNS_13MemoryManagerE:
  139|  4.00M|{
  140|  4.00M|}
_ZN11xercesc_3_26CMNode10getLastPosEv:
  173|  5.39M|{
  174|       |    //
  175|       |    //  Fault in the state set if needed. Since we can't use mutable members
  176|       |    //  cast off the const'ness.
  177|       |    //
  178|  5.39M|    if (!fLastPos)
  ------------------
  |  Branch (178:9): [True: 2.68M, False: 2.71M]
  ------------------
  179|  2.68M|    {
  180|  2.68M|        fLastPos = new (fMemoryManager) CMStateSet(fMaxStates, fMemoryManager);
  181|  2.68M|        calcLastPos(*fLastPos);
  182|  2.68M|    }
  183|  5.39M|    return *fLastPos;
  184|  5.39M|}
_ZN11xercesc_3_26CMNode11getFirstPosEv:
  159|  5.41M|{
  160|       |    //
  161|       |    //  Fault in the state set if needed. Since we can't use mutable members
  162|       |    //  cast off the const'ness.
  163|       |    //
  164|  5.41M|    if (!fFirstPos)
  ------------------
  |  Branch (164:9): [True: 2.68M, False: 2.73M]
  ------------------
  165|  2.68M|    {
  166|  2.68M|        fFirstPos = new (fMemoryManager) CMStateSet(fMaxStates, fMemoryManager);
  167|  2.68M|        calcFirstPos(*fFirstPos);
  168|  2.68M|    }
  169|  5.41M|    return *fFirstPos;
  170|  5.41M|}
_ZNK11xercesc_3_26CMNode7getTypeEv:
  154|  2.79M|{
  155|  2.79M|    return fType;
  156|  2.79M|}

_ZN11xercesc_3_210CMStateSetD2Ev:
  146|  11.0M|    {
  147|  11.0M|        if(fDynamicBuffer)
  ------------------
  |  Branch (147:12): [True: 10.3M, False: 663k]
  ------------------
  148|  10.3M|        {
  149|   231M|            for(XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (149:38): [True: 220M, False: 10.3M]
  ------------------
  150|   220M|                if(fDynamicBuffer->fBitArray[index]!=NULL)
  ------------------
  |  Branch (150:20): [True: 20.8M, False: 200M]
  ------------------
  151|  20.8M|                    deallocateChunk(index);
  152|  10.3M|            fDynamicBuffer->fMemoryManager->deallocate(fDynamicBuffer->fBitArray);
  153|  10.3M|            fDynamicBuffer->fMemoryManager->deallocate(fDynamicBuffer);
  154|  10.3M|        }
  155|  11.0M|    }
_ZN11xercesc_3_210CMStateSet15deallocateChunkEm:
  499|  77.7M|    {
  500|  77.7M|#ifdef XERCES_HAVE_SSE2_INTRINSIC
  501|  77.7M|        if(XMLPlatformUtils::fgSSE2ok)
  ------------------
  |  Branch (501:12): [True: 77.7M, False: 0]
  ------------------
  502|  77.7M|            _mm_free(fDynamicBuffer->fBitArray[index]);
  503|      0|        else
  504|      0|#endif
  505|      0|            fDynamicBuffer->fMemoryManager->deallocate(fDynamicBuffer->fBitArray[index]);
  506|  77.7M|        fDynamicBuffer->fBitArray[index]=NULL;
  507|  77.7M|    }
_ZN11xercesc_3_210CMStateSetC2EmPNS_13MemoryManagerE:
   83|  11.0M|    {
   84|       |        //
   85|       |        //  See if we need to allocate the byte array or whether we can live
   86|       |        //  within the cached bit high performance scheme.
   87|       |        //
   88|  11.0M|        if (fBitCount > (CMSTATE_CACHED_INT32_SIZE * 32))
  ------------------
  |  |   49|  11.0M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (88:13): [True: 10.3M, False: 662k]
  ------------------
   89|  10.3M|        {
   90|  10.3M|            fDynamicBuffer = (CMDynamicBuffer*)manager->allocate(sizeof(CMDynamicBuffer));
   91|  10.3M|            fDynamicBuffer->fMemoryManager = manager;
   92|       |            // allocate an array of vectors, each one containing CMSTATE_BITFIELD_CHUNK bits
   93|  10.3M|            fDynamicBuffer->fArraySize = fBitCount / CMSTATE_BITFIELD_CHUNK;
  ------------------
  |  |   52|  10.3M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
   94|  10.3M|            if (fBitCount % CMSTATE_BITFIELD_CHUNK)
  ------------------
  |  |   52|  10.3M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  |  Branch (94:17): [True: 10.2M, False: 83.7k]
  ------------------
   95|  10.2M|                fDynamicBuffer->fArraySize++;
   96|  10.3M|            fDynamicBuffer->fBitArray = (XMLInt32**) fDynamicBuffer->fMemoryManager->allocate(fDynamicBuffer->fArraySize*sizeof(XMLInt32*));
   97|   231M|            for(XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (97:38): [True: 220M, False: 10.3M]
  ------------------
   98|   220M|                fDynamicBuffer->fBitArray[index]=NULL;
   99|  10.3M|        }
  100|   662k|        else
  101|   662k|        {
  102|  3.31M|            for (XMLSize_t index = 0; index < CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|  3.31M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (102:39): [True: 2.65M, False: 662k]
  ------------------
  103|  2.65M|                fBits[index] = 0;
  104|   662k|        }
  105|  11.0M|    }
_ZN11xercesc_3_220CMStateSetEnumeratorC2EPKNS_10CMStateSetEm:
  540|  69.7M|    {
  541|       |        // if a starting bit is specified, place fIndexCount at the beginning of the previous 32 bit area
  542|       |        // so the findNext moves to the one where 'start' is located
  543|  69.7M|        if(start > 32)
  ------------------
  |  Branch (543:12): [True: 47.0M, False: 22.7M]
  ------------------
  544|  47.0M|            fIndexCount = (start/32 - 1) * 32;
  545|  69.7M|        findNext();
  546|       |        // if we found data, and fIndexCount is still pointing to the area where 'start' is located, erase the bits before 'start'
  547|  69.7M|        if(hasMoreElements() && fIndexCount < start)
  ------------------
  |  Branch (547:12): [True: 66.6M, False: 3.05M]
  |  Branch (547:33): [True: 59.7M, False: 6.87M]
  ------------------
  548|  59.7M|        {
  549|  1.02G|            for(XMLSize_t i=0;i< (start - fIndexCount);i++)
  ------------------
  |  Branch (549:31): [True: 964M, False: 59.7M]
  ------------------
  550|   964M|            {
  551|   964M|                XMLInt32 mask=1UL << i;
  552|   964M|                if(fLastValue & mask)
  ------------------
  |  Branch (552:20): [True: 515M, False: 449M]
  ------------------
  553|   515M|                    fLastValue &= ~mask;
  554|   964M|            }
  555|       |            // in case the 32 bit area contained only bits before 'start', advance
  556|  59.7M|            if(fLastValue==0)
  ------------------
  |  Branch (556:16): [True: 9.09M, False: 50.6M]
  ------------------
  557|  9.09M|                findNext();
  558|  59.7M|        }
  559|  69.7M|    }
_ZN11xercesc_3_220CMStateSetEnumerator8findNextEv:
  585|   105M|    {
  586|   105M|        if(fToEnum->fDynamicBuffer==0)
  ------------------
  |  Branch (586:12): [True: 8.82M, False: 96.9M]
  ------------------
  587|  8.82M|        {
  588|  8.82M|            XMLSize_t nOffset=((fIndexCount==(XMLSize_t)-1)?0:(fIndexCount/32)+1);
  ------------------
  |  Branch (588:32): [True: 2.83M, False: 5.99M]
  ------------------
  589|  10.7M|            for(XMLSize_t index=nOffset;index<CMSTATE_CACHED_INT32_SIZE;index++)
  ------------------
  |  |   49|  10.7M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (589:41): [True: 9.39M, False: 1.31M]
  ------------------
  590|  9.39M|            {
  591|  9.39M|                if(fToEnum->fBits[index]!=0)
  ------------------
  |  Branch (591:20): [True: 7.50M, False: 1.88M]
  ------------------
  592|  7.50M|                {
  593|  7.50M|                    fIndexCount=index*32;
  594|  7.50M|                    fLastValue=fToEnum->fBits[index];
  595|  7.50M|                    return;
  596|  7.50M|                }
  597|  9.39M|            }
  598|  8.82M|        }
  599|  96.9M|        else
  600|  96.9M|        {
  601|  96.9M|            XMLSize_t nOffset=((fIndexCount==(XMLSize_t)-1)?0:(fIndexCount/CMSTATE_BITFIELD_CHUNK));
  ------------------
  |  |   52|  77.0M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  |  Branch (601:32): [True: 19.8M, False: 77.0M]
  ------------------
  602|  96.9M|            XMLSize_t nSubOffset=((fIndexCount==(XMLSize_t)-1)?0:((fIndexCount % CMSTATE_BITFIELD_CHUNK) /32)+1);
  ------------------
  |  |   52|  77.0M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  |  Branch (602:35): [True: 19.8M, False: 77.0M]
  ------------------
  603|   147M|            for (XMLSize_t index = nOffset; index<fToEnum->fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (603:45): [True: 136M, False: 11.5M]
  ------------------
  604|   136M|            {
  605|   136M|                if(fToEnum->fDynamicBuffer->fBitArray[index]!=NULL)
  ------------------
  |  Branch (605:20): [True: 96.7M, False: 39.6M]
  ------------------
  606|  96.7M|                {
  607|   417M|                    for(XMLSize_t subIndex=nSubOffset;subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|   417M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (607:55): [True: 406M, False: 11.3M]
  ------------------
  608|   406M|                        if(fToEnum->fDynamicBuffer->fBitArray[index][subIndex]!=0)
  ------------------
  |  Branch (608:28): [True: 85.3M, False: 321M]
  ------------------
  609|  85.3M|                        {
  610|  85.3M|                            fIndexCount=index*CMSTATE_BITFIELD_CHUNK + subIndex*32;
  ------------------
  |  |   52|  85.3M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  611|  85.3M|                            fLastValue=fToEnum->fDynamicBuffer->fBitArray[index][subIndex];
  612|  85.3M|                            return;
  613|  85.3M|                        }
  614|  96.7M|                }
  615|  51.0M|                nSubOffset = 0; // next chunks will be processed from the beginning
  616|  51.0M|            }
  617|  96.9M|        }
  618|   105M|    }
_ZN11xercesc_3_220CMStateSetEnumerator15hasMoreElementsEv:
  562|   474M|    {
  563|   474M|        return fLastValue!=0;
  564|   474M|    }
_ZN11xercesc_3_220CMStateSetEnumerator11nextElementEv:
  567|   393M|    {
  568|  6.56G|        for(int i=0;i<32;i++)
  ------------------
  |  Branch (568:21): [True: 6.56G, False: 0]
  ------------------
  569|  6.56G|        {
  570|  6.56G|            XMLInt32 mask=1UL << i;
  571|  6.56G|            if(fLastValue & mask)
  ------------------
  |  Branch (571:16): [True: 393M, False: 6.17G]
  ------------------
  572|   393M|            {
  573|   393M|                fLastValue &= ~mask;
  574|   393M|                unsigned int retVal=(unsigned int)fIndexCount+i;
  575|   393M|                if(fLastValue==0)
  ------------------
  |  Branch (575:20): [True: 26.9M, False: 366M]
  ------------------
  576|  26.9M|                    findNext();
  577|   393M|                return retVal;
  578|   393M|            }
  579|  6.56G|        }
  580|      0|        return 0;
  581|   393M|    }
_ZN11xercesc_3_210CMStateSetoRERKS0_:
  162|   276M|    {
  163|   276M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (163:12): [True: 26.5M, False: 249M]
  ------------------
  164|  26.5M|        {
  165|  26.5M|#ifdef XERCES_HAVE_SSE2_INTRINSIC
  166|  26.5M|            if(XMLPlatformUtils::fgSSE2ok)
  ------------------
  |  Branch (166:16): [True: 26.5M, False: 0]
  ------------------
  167|  26.5M|            {
  168|  26.5M|                __m128i xmm1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(fBits));
  169|  26.5M|                __m128i xmm2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(setToOr.fBits));
  170|  26.5M|                __m128i xmm3 = _mm_or_si128(xmm1, xmm2);     //  OR  4 32-bit words
  171|  26.5M|                _mm_storeu_si128(reinterpret_cast<__m128i*>(fBits), xmm3);
  172|  26.5M|            }
  173|      0|            else
  174|      0|#endif
  175|      0|            {
  176|      0|                for (XMLSize_t index = 0; index < CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|      0|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (176:43): [True: 0, False: 0]
  ------------------
  177|      0|                    if(setToOr.fBits[index])
  ------------------
  |  Branch (177:24): [True: 0, False: 0]
  ------------------
  178|      0|                    {
  179|      0|                        if(fBits[index])
  ------------------
  |  Branch (179:28): [True: 0, False: 0]
  ------------------
  180|      0|                            fBits[index] |= setToOr.fBits[index];
  181|      0|                        else
  182|      0|                            fBits[index] = setToOr.fBits[index];
  183|      0|                    }
  184|      0|            }
  185|  26.5M|        }
  186|   249M|        else
  187|   249M|        {
  188|   798M|            for (XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (188:39): [True: 548M, False: 249M]
  ------------------
  189|   548M|            {
  190|   548M|                XMLInt32 *& other = setToOr.fDynamicBuffer->fBitArray[index];
  191|   548M|                if(other!=NULL)
  ------------------
  |  Branch (191:20): [True: 272M, False: 275M]
  ------------------
  192|   272M|                {
  193|       |                    // if we haven't allocated the subvector yet, allocate it and copy
  194|   272M|                    if(fDynamicBuffer->fBitArray[index]==NULL)
  ------------------
  |  Branch (194:24): [True: 72.4M, False: 200M]
  ------------------
  195|  72.4M|                    {
  196|  72.4M|                        allocateChunk(index);
  197|  72.4M|                        memcpy((void *) fDynamicBuffer->fBitArray[index],
  198|  72.4M|                               (const void *) other,
  199|  72.4M|                               CMSTATE_BITFIELD_INT32_SIZE * sizeof(XMLInt32));
  ------------------
  |  |   53|  72.4M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  200|  72.4M|                    }
  201|   200M|                    else
  202|   200M|                    {
  203|       |                        // otherwise, merge them
  204|   200M|                        XMLInt32*& mine = fDynamicBuffer->fBitArray[index];
  205|   200M|#ifdef XERCES_HAVE_SSE2_INTRINSIC
  206|   200M|                        if(XMLPlatformUtils::fgSSE2ok)
  ------------------
  |  Branch (206:28): [True: 200M, False: 0]
  ------------------
  207|   200M|                        {
  208|  1.80G|                            for(XMLSize_t subIndex = 0; subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex+=4)
  ------------------
  |  |   53|  1.80G|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (208:57): [True: 1.60G, False: 200M]
  ------------------
  209|  1.60G|                            {
  210|  1.60G|                               __m128i xmm1 = _mm_load_si128(reinterpret_cast<const __m128i*>(&other[subIndex]));
  211|  1.60G|                               __m128i xmm2 = _mm_load_si128(reinterpret_cast<const __m128i*>(&mine[subIndex]));
  212|  1.60G|                               __m128i xmm3 = _mm_or_si128(xmm1, xmm2);     //  OR  4 32-bit words
  213|  1.60G|                               _mm_store_si128(reinterpret_cast<__m128i*>(&mine[subIndex]), xmm3);
  214|  1.60G|                            }
  215|   200M|                        }
  216|      0|                        else
  217|      0|#endif
  218|      0|                        {
  219|      0|                            for(XMLSize_t subIndex = 0; subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|      0|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (219:57): [True: 0, False: 0]
  ------------------
  220|      0|                                if(setToOr.fDynamicBuffer->fBitArray[index][subIndex])
  ------------------
  |  Branch (220:36): [True: 0, False: 0]
  ------------------
  221|      0|                                {
  222|      0|                                    if(fDynamicBuffer->fBitArray[index][subIndex])
  ------------------
  |  Branch (222:40): [True: 0, False: 0]
  ------------------
  223|      0|                                        fDynamicBuffer->fBitArray[index][subIndex] |= setToOr.fDynamicBuffer->fBitArray[index][subIndex];
  224|      0|                                    else
  225|      0|                                        fDynamicBuffer->fBitArray[index][subIndex] = setToOr.fDynamicBuffer->fBitArray[index][subIndex];
  226|      0|                                }
  227|      0|                        }
  228|   200M|                    }
  229|   272M|                }
  230|   548M|            }
  231|   249M|        }
  232|   276M|    }
_ZN11xercesc_3_210CMStateSet13allocateChunkEm:
  489|  77.7M|    {
  490|  77.7M|#ifdef XERCES_HAVE_SSE2_INTRINSIC
  491|  77.7M|        if(XMLPlatformUtils::fgSSE2ok)
  ------------------
  |  Branch (491:12): [True: 77.7M, False: 0]
  ------------------
  492|  77.7M|            fDynamicBuffer->fBitArray[index]=(XMLInt32*)_mm_malloc(CMSTATE_BITFIELD_INT32_SIZE * sizeof(XMLInt32), 16);
  ------------------
  |  |   53|  77.7M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  493|      0|        else
  494|      0|#endif
  495|      0|            fDynamicBuffer->fBitArray[index]=(XMLInt32*)fDynamicBuffer->fMemoryManager->allocate(CMSTATE_BITFIELD_INT32_SIZE * sizeof(XMLInt32));
  ------------------
  |  |   53|      0|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  496|  77.7M|    }
_ZN11xercesc_3_210CMStateSetC2ERKS0_:
  111|  1.09k|    {
  112|       |        //
  113|       |        //  See if we need to allocate the byte array or whether we can live
  114|       |        //  within the cahced bit high performance scheme.
  115|       |        //
  116|  1.09k|        if (fBitCount > (CMSTATE_CACHED_INT32_SIZE * 32))
  ------------------
  |  |   49|  1.09k|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (116:13): [True: 525, False: 572]
  ------------------
  117|    525|        {
  118|    525|            fDynamicBuffer = (CMDynamicBuffer*) toCopy.fDynamicBuffer->fMemoryManager->allocate(sizeof(CMDynamicBuffer));
  119|    525|            fDynamicBuffer->fMemoryManager = toCopy.fDynamicBuffer->fMemoryManager;
  120|    525|            fDynamicBuffer->fArraySize = fBitCount / CMSTATE_BITFIELD_CHUNK;
  ------------------
  |  |   52|    525|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  121|    525|            if (fBitCount % CMSTATE_BITFIELD_CHUNK)
  ------------------
  |  |   52|    525|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  |  Branch (121:17): [True: 512, False: 13]
  ------------------
  122|    512|                fDynamicBuffer->fArraySize++;
  123|    525|            fDynamicBuffer->fBitArray = (XMLInt32**) fDynamicBuffer->fMemoryManager->allocate(fDynamicBuffer->fArraySize*sizeof(XMLInt32*));
  124|  2.17k|            for(XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (124:38): [True: 1.65k, False: 525]
  ------------------
  125|  1.65k|            {
  126|  1.65k|                if(toCopy.fDynamicBuffer->fBitArray[index]!=NULL)
  ------------------
  |  Branch (126:20): [True: 866, False: 788]
  ------------------
  127|    866|                {
  128|    866|                    allocateChunk(index);
  129|    866|                    memcpy((void *) fDynamicBuffer->fBitArray[index],
  130|    866|                           (const void *) toCopy.fDynamicBuffer->fBitArray[index],
  131|    866|                           CMSTATE_BITFIELD_INT32_SIZE * sizeof(XMLInt32));
  ------------------
  |  |   53|    866|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  132|    866|                }
  133|    788|                else
  134|    788|                    fDynamicBuffer->fBitArray[index]=NULL;
  135|  1.65k|            }
  136|    525|        }
  137|    572|        else
  138|    572|        {
  139|    572|            memcpy((void *) fBits,
  140|    572|                   (const void *) toCopy.fBits,
  141|    572|                   CMSTATE_CACHED_INT32_SIZE * sizeof(XMLInt32));
  ------------------
  |  |   49|    572|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  142|    572|        }
  143|  1.09k|    }
_ZNK11xercesc_3_210CMStateSet6getBitEm:
  352|   497M|    {
  353|   497M|        if (bitToGet >= fBitCount)
  ------------------
  |  Branch (353:13): [True: 0, False: 497M]
  ------------------
  354|      0|        {
  355|      0|            if(fDynamicBuffer)
  ------------------
  |  Branch (355:16): [True: 0, False: 0]
  ------------------
  356|      0|                ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex, fDynamicBuffer->fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  357|      0|            else
  358|      0|                ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex);
  ------------------
  |  |  254|      0|#define ThrowXML(type,code) throw type(__FILE__, __LINE__, code)
  ------------------
  359|      0|        }
  360|       |
  361|       |        // And access the right bit and byte
  362|   497M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (362:12): [True: 42.9M, False: 454M]
  ------------------
  363|  42.9M|        {
  364|  42.9M|            const XMLInt32 mask = 1UL << (bitToGet % 32);
  365|  42.9M|            const XMLSize_t byteOfs = bitToGet / 32;
  366|  42.9M|            return (fBits[byteOfs]!=0 && (fBits[byteOfs] & mask) != 0);
  ------------------
  |  Branch (366:21): [True: 42.0M, False: 859k]
  |  Branch (366:42): [True: 22.4M, False: 19.6M]
  ------------------
  367|  42.9M|        }
  368|   454M|        else
  369|   454M|        {
  370|   454M|            const XMLSize_t vectorOfs = bitToGet / CMSTATE_BITFIELD_CHUNK;
  ------------------
  |  |   52|   454M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  371|   454M|            if(fDynamicBuffer->fBitArray[vectorOfs]==NULL)
  ------------------
  |  Branch (371:16): [True: 28.7M, False: 426M]
  ------------------
  372|  28.7M|                return false;
  373|   426M|            const XMLInt32 mask = 1UL << (bitToGet % 32);
  374|   426M|            const XMLSize_t byteOfs = (bitToGet % CMSTATE_BITFIELD_CHUNK) / 32;
  ------------------
  |  |   52|   426M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  375|   426M|            return (fDynamicBuffer->fBitArray[vectorOfs][byteOfs]!=0 && (fDynamicBuffer->fBitArray[vectorOfs][byteOfs] & mask) != 0);
  ------------------
  |  Branch (375:21): [True: 405M, False: 20.3M]
  |  Branch (375:73): [True: 207M, False: 198M]
  ------------------
  376|   454M|        }
  377|   497M|    }
_ZN11xercesc_3_210CMStateSet8zeroBitsEv:
  440|  97.4M|    {
  441|  97.4M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (441:12): [True: 10.5M, False: 86.9M]
  ------------------
  442|  10.5M|        {
  443|  52.6M|            for (XMLSize_t index = 0; index < CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|  52.6M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (443:39): [True: 42.1M, False: 10.5M]
  ------------------
  444|  42.1M|                fBits[index] = 0;
  445|  10.5M|        }
  446|  86.9M|        else
  447|  86.9M|        {
  448|   228M|            for (XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (448:39): [True: 141M, False: 86.9M]
  ------------------
  449|       |                // delete this subentry
  450|   141M|                if(fDynamicBuffer->fBitArray[index]!=NULL)
  ------------------
  |  Branch (450:20): [True: 56.9M, False: 84.8M]
  ------------------
  451|  56.9M|                    deallocateChunk(index);
  452|  86.9M|        }
  453|  97.4M|    }
_ZNK11xercesc_3_210CMStateSet18getBitCountInRangeEmm:
  310|   101M|    {
  311|   101M|        XMLSize_t count = 0;
  312|   101M|        end /= 32;
  313|   101M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (313:12): [True: 11.0M, False: 90.6M]
  ------------------
  314|  11.0M|        {
  315|  11.0M|            if(end > CMSTATE_CACHED_INT32_SIZE)
  ------------------
  |  |   49|  11.0M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (315:16): [True: 0, False: 11.0M]
  ------------------
  316|      0|                end = CMSTATE_CACHED_INT32_SIZE;
  ------------------
  |  |   49|      0|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  317|  18.6M|            for (XMLSize_t index = start / 32; index < end; index++)
  ------------------
  |  Branch (317:48): [True: 7.59M, False: 11.0M]
  ------------------
  318|  7.59M|            {
  319|  7.59M|                if (fBits[index] != 0)
  ------------------
  |  Branch (319:21): [True: 7.42M, False: 166k]
  ------------------
  320|   245M|                    for(int i=0;i<32;i++)
  ------------------
  |  Branch (320:33): [True: 237M, False: 7.42M]
  ------------------
  321|   237M|                    {
  322|   237M|                        const XMLInt32 mask = 1UL << i;
  323|   237M|                        if(fBits[index] & mask)
  ------------------
  |  Branch (323:28): [True: 124M, False: 112M]
  ------------------
  324|   124M|                            count++;
  325|   237M|                    }
  326|  7.59M|            }
  327|  11.0M|        }
  328|  90.6M|        else
  329|  90.6M|        {
  330|  90.6M|            if(end > fDynamicBuffer->fArraySize)
  ------------------
  |  Branch (330:16): [True: 61.5M, False: 29.1M]
  ------------------
  331|  61.5M|                end = fDynamicBuffer->fArraySize;
  332|   138M|            for (XMLSize_t index = start / 32; index < end; index++)
  ------------------
  |  Branch (332:48): [True: 48.2M, False: 90.6M]
  ------------------
  333|  48.2M|            {
  334|  48.2M|                if(fDynamicBuffer->fBitArray[index]==NULL)
  ------------------
  |  Branch (334:20): [True: 18.9M, False: 29.3M]
  ------------------
  335|  18.9M|                    continue;
  336|   967M|                for(XMLSize_t subIndex=0;subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|   967M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (336:42): [True: 937M, False: 29.3M]
  ------------------
  337|   937M|                {
  338|   937M|                    if (fDynamicBuffer->fBitArray[index][subIndex] != 0)
  ------------------
  |  Branch (338:25): [True: 132M, False: 805M]
  ------------------
  339|  4.36G|                        for(int i=0;i<32;i++)
  ------------------
  |  Branch (339:37): [True: 4.23G, False: 132M]
  ------------------
  340|  4.23G|                        {
  341|  4.23G|                            const XMLInt32 mask = 1UL << i;
  342|  4.23G|                            if(fDynamicBuffer->fBitArray[index][subIndex] & mask)
  ------------------
  |  Branch (342:32): [True: 1.93G, False: 2.30G]
  ------------------
  343|  1.93G|                                count++;
  344|  4.23G|                        }
  345|   937M|                }
  346|  29.3M|            }
  347|  90.6M|        }
  348|   101M|        return count;
  349|   101M|    }
_ZNK11xercesc_3_210CMStateSet7isEmptyEv:
  380|   101M|    {
  381|   101M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (381:12): [True: 11.0M, False: 90.6M]
  ------------------
  382|  11.0M|        {
  383|  27.4M|            for (XMLSize_t index = 0; index < CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|  27.4M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (383:39): [True: 23.9M, False: 3.49M]
  ------------------
  384|  23.9M|            {
  385|  23.9M|                if (fBits[index] != 0)
  ------------------
  |  Branch (385:21): [True: 7.57M, False: 16.3M]
  ------------------
  386|  7.57M|                    return false;
  387|  23.9M|            }
  388|  11.0M|        }
  389|  90.6M|        else
  390|  90.6M|        {
  391|   173M|            for (XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (391:39): [True: 143M, False: 30.0M]
  ------------------
  392|   143M|            {
  393|   143M|                if(fDynamicBuffer->fBitArray[index]==NULL)
  ------------------
  |  Branch (393:20): [True: 83.1M, False: 60.6M]
  ------------------
  394|  83.1M|                    continue;
  395|   107M|                for(XMLSize_t subIndex=0;subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|   107M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (395:42): [True: 107M, False: 0]
  ------------------
  396|   107M|                {
  397|   107M|                    if (fDynamicBuffer->fBitArray[index][subIndex] != 0)
  ------------------
  |  Branch (397:25): [True: 60.6M, False: 46.4M]
  ------------------
  398|  60.6M|                        return false;
  399|   107M|                }
  400|  60.6M|            }
  401|  90.6M|        }
  402|  33.5M|        return true;
  403|   101M|    }
_ZN11xercesc_3_210CMStateSet6setBitEm:
  406|  2.64M|    {
  407|  2.64M|        if (bitToSet >= fBitCount)
  ------------------
  |  Branch (407:13): [True: 0, False: 2.64M]
  ------------------
  408|      0|        {
  409|      0|            if(fDynamicBuffer)
  ------------------
  |  Branch (409:16): [True: 0, False: 0]
  ------------------
  410|      0|                ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex, fDynamicBuffer->fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  411|      0|            else
  412|      0|                ThrowXML(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex);
  ------------------
  |  |  254|      0|#define ThrowXML(type,code) throw type(__FILE__, __LINE__, code)
  ------------------
  413|      0|        }
  414|       |
  415|  2.64M|        const XMLInt32 mask = 1UL << (bitToSet % 32);
  416|       |
  417|       |        // And access the right bit and byte
  418|  2.64M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (418:12): [True: 46.3k, False: 2.59M]
  ------------------
  419|  46.3k|        {
  420|  46.3k|            const XMLSize_t byteOfs = bitToSet / 32;
  421|  46.3k|            fBits[byteOfs] &= ~mask;
  422|  46.3k|            fBits[byteOfs] |= mask;
  423|  46.3k|        }
  424|  2.59M|        else
  425|  2.59M|        {
  426|  2.59M|            const XMLSize_t vectorOfs = bitToSet / CMSTATE_BITFIELD_CHUNK;
  ------------------
  |  |   52|  2.59M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  427|  2.59M|            if(fDynamicBuffer->fBitArray[vectorOfs]==NULL)
  ------------------
  |  Branch (427:16): [True: 2.59M, False: 0]
  ------------------
  428|  2.59M|            {
  429|  2.59M|                allocateChunk(vectorOfs);
  430|  85.7M|                for(XMLSize_t index=0;index < CMSTATE_BITFIELD_INT32_SIZE; index++)
  ------------------
  |  |   53|  85.7M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (430:39): [True: 83.1M, False: 2.59M]
  ------------------
  431|  83.1M|                    fDynamicBuffer->fBitArray[vectorOfs][index]=0;
  432|  2.59M|            }
  433|  2.59M|            const XMLSize_t byteOfs = (bitToSet % CMSTATE_BITFIELD_CHUNK) / 32;
  ------------------
  |  |   52|  2.59M|#define CMSTATE_BITFIELD_CHUNK  1024
  ------------------
  434|  2.59M|            fDynamicBuffer->fBitArray[vectorOfs][byteOfs] &= ~mask;
  435|  2.59M|            fDynamicBuffer->fBitArray[vectorOfs][byteOfs] |= mask;
  436|  2.59M|        }
  437|  2.64M|    }
_ZNK11xercesc_3_210CMStateSet8hashCodeEv:
  456|  77.5M|    {
  457|  77.5M|        XMLSize_t hash = 0;
  458|  77.5M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (458:12): [True: 9.08M, False: 68.4M]
  ------------------
  459|  9.08M|        {
  460|  45.4M|            for (XMLSize_t index = 0; index<CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|  45.4M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (460:39): [True: 36.3M, False: 9.08M]
  ------------------
  461|  36.3M|                hash = fBits[index] + hash * 31;
  462|  9.08M|        }
  463|  68.4M|        else
  464|  68.4M|        {
  465|   141M|            for (XMLSize_t index = 0; index<fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (465:39): [True: 72.8M, False: 68.4M]
  ------------------
  466|  72.8M|            {
  467|  72.8M|                if(fDynamicBuffer->fBitArray[index]==NULL)
  ------------------
  |  Branch (467:20): [True: 4.29M, False: 68.5M]
  ------------------
  468|       |                    // simulates the iteration on the missing bits
  469|   141M|                    for(XMLSize_t subIndex=0;subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|   141M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (469:46): [True: 137M, False: 4.29M]
  ------------------
  470|   137M|                        hash *= 31;
  471|  68.5M|                else
  472|  2.26G|                    for(XMLSize_t subIndex=0;subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|  2.26G|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (472:46): [True: 2.19G, False: 68.5M]
  ------------------
  473|  2.19G|                        hash = fDynamicBuffer->fBitArray[index][subIndex] + hash * 31;
  474|  72.8M|            }
  475|  68.4M|        }
  476|  77.5M|        return hash;
  477|  77.5M|    }
_ZNK11xercesc_3_210CMStateSeteqERKS0_:
  235|  83.0M|    {
  236|  83.0M|        if (fBitCount != setToCompare.fBitCount)
  ------------------
  |  Branch (236:13): [True: 0, False: 83.0M]
  ------------------
  237|      0|            return false;
  238|       |
  239|  83.0M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (239:12): [True: 9.62M, False: 73.4M]
  ------------------
  240|  9.62M|        {
  241|  37.8M|            for (XMLSize_t index = 0; index < CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|  37.8M|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (241:39): [True: 30.8M, False: 7.03M]
  ------------------
  242|  30.8M|            {
  243|  30.8M|                if (fBits[index] != setToCompare.fBits[index])
  ------------------
  |  Branch (243:21): [True: 2.58M, False: 28.2M]
  ------------------
  244|  2.58M|                    return false;
  245|  30.8M|            }
  246|  9.62M|        }
  247|  73.4M|        else
  248|  73.4M|        {
  249|   133M|            for (XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (249:39): [True: 76.7M, False: 56.8M]
  ------------------
  250|  76.7M|            {
  251|  76.7M|                XMLInt32 *& other = setToCompare.fDynamicBuffer->fBitArray[index],
  252|  76.7M|                         *& mine = fDynamicBuffer->fBitArray[index];
  253|  76.7M|                if(mine==NULL && other==NULL)
  ------------------
  |  Branch (253:20): [True: 3.23M, False: 73.5M]
  |  Branch (253:34): [True: 3.21M, False: 26.7k]
  ------------------
  254|  3.21M|                    continue;
  255|  73.5M|                else if(mine==NULL || other==NULL) // the other should have been empty too
  ------------------
  |  Branch (255:25): [True: 26.7k, False: 73.5M]
  |  Branch (255:39): [True: 508, False: 73.5M]
  ------------------
  256|  27.2k|                    return false;
  257|  73.5M|                else
  258|  73.5M|                {
  259|  1.89G|                    for(XMLSize_t subIndex = 0; subIndex < CMSTATE_BITFIELD_INT32_SIZE; subIndex++)
  ------------------
  |  |   53|  1.89G|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  |  Branch (259:49): [True: 1.84G, False: 56.9M]
  ------------------
  260|  1.84G|                        if(mine[subIndex]!=other[subIndex])
  ------------------
  |  Branch (260:28): [True: 16.6M, False: 1.82G]
  ------------------
  261|  16.6M|                            return false;
  262|  73.5M|                }
  263|  76.7M|            }
  264|  73.4M|        }
  265|  63.8M|        return true;
  266|  83.0M|    }
_ZN11xercesc_3_210CMStateSetaSERKS0_:
  269|  2.71M|    {
  270|  2.71M|        if (this == &srcSet)
  ------------------
  |  Branch (270:13): [True: 0, False: 2.71M]
  ------------------
  271|      0|            return *this;
  272|       |
  273|       |        // They have to be the same size
  274|  2.71M|        if (fBitCount != srcSet.fBitCount)
  ------------------
  |  Branch (274:13): [True: 0, False: 2.71M]
  ------------------
  275|      0|        {
  276|      0|            if(fDynamicBuffer)
  ------------------
  |  Branch (276:16): [True: 0, False: 0]
  ------------------
  277|      0|                ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Bitset_NotEqualSize, fDynamicBuffer->fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  278|      0|            else
  279|      0|                ThrowXML(RuntimeException, XMLExcepts::Bitset_NotEqualSize);
  ------------------
  |  |  254|      0|#define ThrowXML(type,code) throw type(__FILE__, __LINE__, code)
  ------------------
  280|      0|        }
  281|       |
  282|  2.71M|        if(fDynamicBuffer==0)
  ------------------
  |  Branch (282:12): [True: 50.8k, False: 2.66M]
  ------------------
  283|  50.8k|        {
  284|   254k|            for (XMLSize_t index = 0; index < CMSTATE_CACHED_INT32_SIZE; index++)
  ------------------
  |  |   49|   254k|#define CMSTATE_CACHED_INT32_SIZE  4
  ------------------
  |  Branch (284:39): [True: 203k, False: 50.8k]
  ------------------
  285|   203k|                fBits[index] = srcSet.fBits[index];
  286|  50.8k|        }
  287|  2.66M|        else
  288|  2.66M|        {
  289|  89.9M|            for (XMLSize_t index = 0; index < fDynamicBuffer->fArraySize; index++)
  ------------------
  |  Branch (289:39): [True: 87.2M, False: 2.66M]
  ------------------
  290|  87.2M|                if(srcSet.fDynamicBuffer->fBitArray[index]==NULL)
  ------------------
  |  Branch (290:20): [True: 84.5M, False: 2.73M]
  ------------------
  291|  84.5M|                {
  292|       |                    // delete this subentry
  293|  84.5M|                    if(fDynamicBuffer->fBitArray[index]!=NULL)
  ------------------
  |  Branch (293:24): [True: 0, False: 84.5M]
  ------------------
  294|      0|                        deallocateChunk(index);
  295|  84.5M|                }
  296|  2.73M|                else
  297|  2.73M|                {
  298|       |                    // if we haven't allocated the subvector yet, allocate it and copy
  299|  2.73M|                    if(fDynamicBuffer->fBitArray[index]==NULL)
  ------------------
  |  Branch (299:24): [True: 2.73M, False: 0]
  ------------------
  300|  2.73M|                        allocateChunk(index);
  301|  2.73M|                    memcpy((void *) fDynamicBuffer->fBitArray[index],
  302|  2.73M|                           (const void *) srcSet.fDynamicBuffer->fBitArray[index],
  303|  2.73M|                           CMSTATE_BITFIELD_INT32_SIZE * sizeof(XMLInt32));
  ------------------
  |  |   53|  2.73M|#define CMSTATE_BITFIELD_INT32_SIZE (1024 / 32)
  ------------------
  304|  2.73M|                }
  305|  2.66M|        }
  306|  2.71M|        return *this;
  307|  2.71M|    }

_ZN11xercesc_3_29CMUnaryOpC2ENS_15ContentSpecNode9NodeTypesEPNS_6CMNodeEjPNS_13MemoryManagerE:
   41|  38.5k|{
   42|       |    // Insure that its one of the types we require
   43|  38.5k|    if ((type != ContentSpecNode::ZeroOrOne)
  ------------------
  |  Branch (43:9): [True: 29.6k, False: 8.83k]
  ------------------
   44|  38.5k|    &&  (type != ContentSpecNode::ZeroOrMore)
  ------------------
  |  Branch (44:9): [True: 6.81k, False: 22.8k]
  ------------------
   45|  38.5k|    &&  (type != ContentSpecNode::OneOrMore))
  ------------------
  |  Branch (45:9): [True: 0, False: 6.81k]
  ------------------
   46|      0|    {
   47|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnaryOpHadBinType, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   48|      0|    }
   49|  38.5k|    if (type == ContentSpecNode::OneOrMore)
  ------------------
  |  Branch (49:9): [True: 6.81k, False: 31.6k]
  ------------------
   50|  6.81k|        fIsNullable=fChild->isNullable();
   51|  31.6k|    else
   52|  31.6k|        fIsNullable=true;
   53|  38.5k|}
_ZN11xercesc_3_29CMUnaryOpD2Ev:
   56|  38.5k|{
   57|  38.5k|    delete fChild;
   58|  38.5k|}
_ZN11xercesc_3_29CMUnaryOp11orphanChildEv:
   79|  38.5k|{
   80|  38.5k|    delete fChild;
   81|  38.5k|    fChild=0;
   82|  38.5k|}
_ZNK11xercesc_3_29CMUnaryOp12calcFirstPosERNS_10CMStateSetE:
   88|  38.5k|{
   89|       |    // Its just based on our child node's first pos
   90|  38.5k|    toSet = fChild->getFirstPos();
   91|  38.5k|}
_ZNK11xercesc_3_29CMUnaryOp11calcLastPosERNS_10CMStateSetE:
   94|  38.5k|{
   95|       |    // Its just based on our child node's last pos
   96|  38.5k|    toSet = fChild->getLastPos();
   97|  38.5k|}

_ZN11xercesc_3_215ContentSpecNodeD2Ev:
   69|  3.07M|{
   70|       |    // Delete our children, avoiding recursive cleanup
   71|  3.07M|    if (fAdoptFirst && fFirst) {
  ------------------
  |  Branch (71:9): [True: 3.07M, False: 0]
  |  Branch (71:24): [True: 5.69k, False: 3.06M]
  ------------------
   72|  5.69k|		deleteChildNode(fFirst);
   73|  5.69k|    }
   74|       |
   75|  3.07M|    if (fAdoptSecond && fSecond) {
  ------------------
  |  Branch (75:9): [True: 3.07M, False: 0]
  |  Branch (75:25): [True: 1.95k, False: 3.07M]
  ------------------
   76|  1.95k|		deleteChildNode(fSecond);
   77|  1.95k|    }
   78|       |
   79|  3.07M|    delete fElement;
   80|  3.07M|}
_ZN11xercesc_3_215ContentSpecNode15deleteChildNodeEPS0_:
   83|  7.65k|{
   84|  7.65k|	ValueStackOf<ContentSpecNode*> toBeDeleted(10, fMemoryManager);
   85|  7.65k|	toBeDeleted.push(node);
   86|  6.12M|	while(!toBeDeleted.empty())
  ------------------
  |  Branch (86:8): [True: 6.11M, False: 7.65k]
  ------------------
   87|  6.11M|	{
   88|  6.11M|		ContentSpecNode* node = toBeDeleted.pop();
   89|  6.11M|		if(node==0)
  ------------------
  |  Branch (89:6): [True: 3.06M, False: 3.05M]
  ------------------
   90|  3.06M|			continue;
   91|  3.05M|		if(node->isFirstAdopted())
  ------------------
  |  Branch (91:6): [True: 3.05M, False: 0]
  ------------------
   92|  3.05M|			toBeDeleted.push(node->orphanFirst());
   93|  3.05M|		if(node->isSecondAdopted())
  ------------------
  |  Branch (93:6): [True: 3.05M, False: 0]
  ------------------
   94|  3.05M|			toBeDeleted.push(node->orphanSecond());
   95|  3.05M|		delete node;
   96|  3.05M|	}
   97|  7.65k|}
_ZNK11xercesc_3_215ContentSpecNode10formatSpecERNS_9XMLBufferE:
  261|  1.35k|{
  262|       |    // Clean out the buffer first
  263|  1.35k|    bufToFill.reset();
  264|       |
  265|  1.35k|    if (fType == ContentSpecNode::Leaf)
  ------------------
  |  Branch (265:9): [True: 128, False: 1.22k]
  ------------------
  266|    128|        bufToFill.append(chOpenParen);
  267|  1.35k|    formatNode
  268|  1.35k|    (
  269|  1.35k|        this
  270|  1.35k|		, bufToFill
  271|  1.35k|        , fMemoryManager
  272|  1.35k|    );
  273|  1.35k|    if (fType == ContentSpecNode::Leaf)
  ------------------
  |  Branch (273:9): [True: 128, False: 1.22k]
  ------------------
  274|    128|        bufToFill.append(chCloseParen);
  275|  1.35k|}
ContentSpecNode.cpp:_ZN11xercesc_3_2L10formatNodeEPKNS_15ContentSpecNodeERNS_9XMLBufferEPNS_13MemoryManagerE:
  122|  1.35k|{
  123|  1.35k|    if (!curNode)
  ------------------
  |  Branch (123:9): [True: 0, False: 1.35k]
  ------------------
  124|      0|        return;
  125|       |
  126|  1.35k|	ValueStackOf<formatNodeHolder> toBeProcessed(10, memMgr);
  127|  1.35k|	toBeProcessed.push(formatNodeHolder(curNode, ContentSpecNode::UnknownType, 0));
  128|       |
  129|  3.81M|	while(!toBeProcessed.empty())
  ------------------
  |  Branch (129:8): [True: 3.81M, False: 1.35k]
  ------------------
  130|  3.81M|	{
  131|  3.81M|		formatNodeHolder item=toBeProcessed.pop();
  132|  3.81M|		if(item.character!=0)
  ------------------
  |  Branch (132:6): [True: 1.29M, False: 2.51M]
  ------------------
  133|  1.29M|		{
  134|  1.29M|			bufToFill.append(item.character);
  135|  1.29M|			continue;
  136|  1.29M|		}
  137|  2.51M|		const ContentSpecNode* curNode = item.node;
  138|  2.51M|		if(!curNode)
  ------------------
  |  Branch (138:6): [True: 0, False: 2.51M]
  ------------------
  139|      0|			continue;
  140|  2.51M|		const ContentSpecNode::NodeTypes parentType = item.parentType; 
  141|  2.51M|		const ContentSpecNode* first = curNode->getFirst();
  142|  2.51M|		const ContentSpecNode* second = curNode->getSecond();
  143|  2.51M|		const ContentSpecNode::NodeTypes curType = curNode->getType();
  144|       |
  145|       |		// Get the type of the first node
  146|  2.51M|		const ContentSpecNode::NodeTypes firstType = first ?
  ------------------
  |  Branch (146:48): [True: 1.27M, False: 1.24M]
  ------------------
  147|  1.27M|													 first->getType() :
  148|  2.51M|													 ContentSpecNode::Leaf;
  149|       |
  150|       |		// Calculate the parens flag for the rep nodes
  151|  2.51M|		bool doRepParens = false;
  152|  2.51M|		if (((firstType != ContentSpecNode::Leaf)
  ------------------
  |  Branch (152:8): [True: 43.0k, False: 2.47M]
  ------------------
  153|  2.51M|				&& (parentType != ContentSpecNode::UnknownType))
  ------------------
  |  Branch (153:8): [True: 42.4k, False: 540]
  ------------------
  154|  2.51M|		||  ((firstType == ContentSpecNode::Leaf)
  ------------------
  |  Branch (154:8): [True: 2.47M, False: 540]
  ------------------
  155|  2.47M|				&& (parentType == ContentSpecNode::UnknownType)))
  ------------------
  |  Branch (155:8): [True: 810, False: 2.47M]
  ------------------
  156|  43.2k|		{
  157|  43.2k|			doRepParens = true;
  158|  43.2k|		}
  159|       |
  160|       |		// Now handle our type
  161|  2.51M|		switch(curType & 0x0f)
  ------------------
  |  Branch (161:10): [True: 0, False: 2.51M]
  ------------------
  162|  2.51M|		{
  163|  1.24M|			case ContentSpecNode::Leaf :
  ------------------
  |  Branch (163:4): [True: 1.24M, False: 1.27M]
  ------------------
  164|  1.24M|				if (curNode->getElement()->getURI() == XMLElementDecl::fgPCDataElemId)
  ------------------
  |  Branch (164:9): [True: 73, False: 1.24M]
  ------------------
  165|     73|					bufToFill.append(XMLElementDecl::fgPCDataElemName);
  166|  1.24M|				else
  167|  1.24M|				{
  168|  1.24M|					bufToFill.append(curNode->getElement()->getRawName());
  169|       |					// show the + and * modifiers also when we have a non-infinite number of repetitions
  170|  1.24M|					if(curNode->getMinOccurs()==0 && (curNode->getMaxOccurs()==-1 || curNode->getMaxOccurs()>1))
  ------------------
  |  Branch (170:9): [True: 0, False: 1.24M]
  |  Branch (170:40): [True: 0, False: 0]
  |  Branch (170:71): [True: 0, False: 0]
  ------------------
  171|      0|						bufToFill.append(chAsterisk);
  172|  1.24M|					else if(curNode->getMinOccurs()==0 && curNode->getMaxOccurs()==1)
  ------------------
  |  Branch (172:14): [True: 0, False: 1.24M]
  |  Branch (172:44): [True: 0, False: 0]
  ------------------
  173|      0|						bufToFill.append(chQuestion);
  174|  1.24M|					else if(curNode->getMinOccurs()==1 && (curNode->getMaxOccurs()==-1 || curNode->getMaxOccurs()>1))
  ------------------
  |  Branch (174:14): [True: 1.24M, False: 0]
  |  Branch (174:45): [True: 0, False: 1.24M]
  |  Branch (174:76): [True: 0, False: 1.24M]
  ------------------
  175|      0|						bufToFill.append(chPlus);
  176|  1.24M|				}
  177|  1.24M|				break;
  178|       |
  179|  8.77k|			case ContentSpecNode::ZeroOrOne :
  ------------------
  |  Branch (179:4): [True: 8.77k, False: 2.50M]
  ------------------
  180|  8.77k|				if (doRepParens)
  ------------------
  |  Branch (180:9): [True: 1.30k, False: 7.46k]
  ------------------
  181|  1.30k|					bufToFill.append(chOpenParen);
  182|       |
  183|  8.77k|				toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chQuestion));
  184|  8.77k|				if (doRepParens)
  ------------------
  |  Branch (184:9): [True: 1.30k, False: 7.46k]
  ------------------
  185|  1.30k|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chCloseParen));
  186|  8.77k|				toBeProcessed.push(formatNodeHolder(first, curType, 0));
  187|  8.77k|				break;
  188|       |
  189|  22.4k|			case ContentSpecNode::ZeroOrMore :
  ------------------
  |  Branch (189:4): [True: 22.4k, False: 2.49M]
  ------------------
  190|  22.4k|				if (doRepParens)
  ------------------
  |  Branch (190:9): [True: 4.62k, False: 17.7k]
  ------------------
  191|  4.62k|					bufToFill.append(chOpenParen);
  192|       |
  193|  22.4k|				toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chAsterisk));
  194|  22.4k|				if (doRepParens)
  ------------------
  |  Branch (194:9): [True: 4.62k, False: 17.7k]
  ------------------
  195|  4.62k|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chCloseParen));
  196|  22.4k|				toBeProcessed.push(formatNodeHolder(first, curType, 0));
  197|  22.4k|				break;
  198|       |
  199|  6.57k|			case ContentSpecNode::OneOrMore :
  ------------------
  |  Branch (199:4): [True: 6.57k, False: 2.51M]
  ------------------
  200|  6.57k|				if (doRepParens)
  ------------------
  |  Branch (200:9): [True: 779, False: 5.79k]
  ------------------
  201|    779|					bufToFill.append(chOpenParen);
  202|       |
  203|  6.57k|				toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chPlus));
  204|  6.57k|				if (doRepParens)
  ------------------
  |  Branch (204:9): [True: 779, False: 5.79k]
  ------------------
  205|    779|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chCloseParen));
  206|  6.57k|				toBeProcessed.push(formatNodeHolder(first, curType, 0));
  207|  6.57k|				break;
  208|       |
  209|  1.16M|			case ContentSpecNode::Choice :
  ------------------
  |  Branch (209:4): [True: 1.16M, False: 1.35M]
  ------------------
  210|  1.16M|				if ((parentType & 0x0f) != (curType & 0x0f))
  ------------------
  |  Branch (210:9): [True: 9.57k, False: 1.15M]
  ------------------
  211|  9.57k|					bufToFill.append(chOpenParen);
  212|       |
  213|  1.16M|				if ((parentType & 0x0f) != (curType & 0x0f))
  ------------------
  |  Branch (213:9): [True: 9.57k, False: 1.15M]
  ------------------
  214|  9.57k|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chCloseParen));
  215|  1.16M|				if(second!=NULL)
  ------------------
  |  Branch (215:8): [True: 1.16M, False: 0]
  ------------------
  216|  1.16M|				{
  217|  1.16M|					toBeProcessed.push(formatNodeHolder(second, curType, 0));
  218|  1.16M|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chPipe));
  219|  1.16M|				}
  220|  1.16M|				toBeProcessed.push(formatNodeHolder(first, curType, 0));
  221|  1.16M|				break;
  222|       |
  223|  74.5k|			case ContentSpecNode::Sequence :
  ------------------
  |  Branch (223:4): [True: 74.5k, False: 2.44M]
  ------------------
  224|  74.5k|				if ((parentType & 0x0f) != (curType & 0x0f))
  ------------------
  |  Branch (224:9): [True: 1.38k, False: 73.1k]
  ------------------
  225|  1.38k|					bufToFill.append(chOpenParen);
  226|       |
  227|  74.5k|				if ((parentType & 0x0f) != (curType & 0x0f))
  ------------------
  |  Branch (227:9): [True: 1.38k, False: 73.1k]
  ------------------
  228|  1.38k|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chCloseParen));
  229|  74.5k|				if(second!=NULL)
  ------------------
  |  Branch (229:8): [True: 74.5k, False: 0]
  ------------------
  230|  74.5k|				{
  231|  74.5k|					toBeProcessed.push(formatNodeHolder(second, curType, 0));
  232|  74.5k|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chComma));
  233|  74.5k|				}
  234|  74.5k|				toBeProcessed.push(formatNodeHolder(first, curType, 0));
  235|  74.5k|				break;
  236|       |
  237|      0|			case ContentSpecNode::All :
  ------------------
  |  Branch (237:4): [True: 0, False: 2.51M]
  ------------------
  238|      0|				if ((parentType & 0x0f) != (curType & 0x0f))
  ------------------
  |  Branch (238:9): [True: 0, False: 0]
  ------------------
  239|      0|				{
  240|      0|					bufToFill.append(chLatin_A);
  241|      0|					bufToFill.append(chLatin_l);
  242|      0|					bufToFill.append(chLatin_l);
  243|      0|					bufToFill.append(chOpenParen);
  244|      0|				}
  245|       |
  246|      0|				if ((parentType & 0x0f) != (curType & 0x0f))
  ------------------
  |  Branch (246:9): [True: 0, False: 0]
  ------------------
  247|      0|					toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chCloseParen));
  248|      0|				toBeProcessed.push(formatNodeHolder(second, curType, 0));
  249|      0|				toBeProcessed.push(formatNodeHolder(0, ContentSpecNode::UnknownType, chComma));
  250|      0|				toBeProcessed.push(formatNodeHolder(first, curType, 0));
  251|      0|				break;
  252|  2.51M|		}
  253|  2.51M|	}
  254|  1.35k|}
_ZN11xercesc_3_216formatNodeHolderC2EPKNS_15ContentSpecNodeENS1_9NodeTypesEDs:
  102|  3.81M|	formatNodeHolder(const ContentSpecNode* n, const ContentSpecNode::NodeTypes p, XMLCh c) : node(n), parentType(p), character(c) {}

_ZN11xercesc_3_215ContentSpecNode10getElementEv:
  314|  2.69M|{
  315|  2.69M|    return fElement;
  316|  2.69M|}
_ZNK11xercesc_3_215ContentSpecNode10getElementEv:
  319|  2.48M|{
  320|  2.48M|    return fElement;
  321|  2.48M|}
_ZN11xercesc_3_215ContentSpecNode8getFirstEv:
  334|  3.06M|{
  335|  3.06M|    return fFirst;
  336|  3.06M|}
_ZNK11xercesc_3_215ContentSpecNode8getFirstEv:
  339|  2.51M|{
  340|  2.51M|    return fFirst;
  341|  2.51M|}
_ZN11xercesc_3_215ContentSpecNode9getSecondEv:
  344|  2.97M|{
  345|  2.97M|    return fSecond;
  346|  2.97M|}
_ZNK11xercesc_3_215ContentSpecNode9getSecondEv:
  349|  2.51M|{
  350|  2.51M|    return fSecond;
  351|  2.51M|}
_ZNK11xercesc_3_215ContentSpecNode7getTypeEv:
  354|  11.9M|{
  355|  11.9M|    return fType;
  356|  11.9M|}
_ZN11xercesc_3_215ContentSpecNode11orphanFirstEv:
  359|  3.06M|{
  360|  3.06M|    ContentSpecNode* retNode = fFirst;
  361|  3.06M|    fFirst = 0;
  362|  3.06M|    return retNode;
  363|  3.06M|}
_ZN11xercesc_3_215ContentSpecNode12orphanSecondEv:
  366|  3.10M|{
  367|  3.10M|    ContentSpecNode* retNode = fSecond;
  368|  3.10M|    fSecond = 0;
  369|  3.10M|    return retNode;
  370|  3.10M|}
_ZNK11xercesc_3_215ContentSpecNode12getMinOccursEv:
  373|  3.72M|{
  374|  3.72M|    return fMinOccurs;
  375|  3.72M|}
_ZNK11xercesc_3_215ContentSpecNode12getMaxOccursEv:
  378|  2.48M|{
  379|  2.48M|    return fMaxOccurs;
  380|  2.48M|}
_ZNK11xercesc_3_215ContentSpecNode14isFirstAdoptedEv:
  383|  3.05M|{
  384|  3.05M|    return fAdoptFirst;
  385|  3.05M|}
_ZNK11xercesc_3_215ContentSpecNode15isSecondAdoptedEv:
  388|  3.05M|{
  389|  3.05M|    return fAdoptSecond;
  390|  3.05M|}
_ZN11xercesc_3_215ContentSpecNode9setSecondEPS0_:
  412|  1.51M|{
  413|  1.51M|    if (fAdoptSecond)
  ------------------
  |  Branch (413:9): [True: 1.51M, False: 0]
  ------------------
  414|  1.51M|        delete fSecond;
  415|  1.51M|    fSecond = toAdopt;
  416|  1.51M|}
_ZN11xercesc_3_215ContentSpecNode7setTypeENS0_9NodeTypesE:
  419|      1|{
  420|      1|    fType = type;
  421|      1|}
_ZN11xercesc_3_215ContentSpecNode12setMinOccursEi:
  424|      1|{
  425|      1|    fMinOccurs = min;
  426|      1|}
_ZN11xercesc_3_215ContentSpecNode12setMaxOccursEi:
  429|      1|{
  430|      1|    fMaxOccurs = max;
  431|      1|}
_ZN11xercesc_3_215ContentSpecNodeC2EPNS_5QNameEbPNS_13MemoryManagerE:
  277|    918|{
  278|    918|    if (copyQName)
  ------------------
  |  Branch (278:9): [True: 0, False: 918]
  ------------------
  279|      0|    {
  280|      0|        if (element)
  ------------------
  |  Branch (280:13): [True: 0, False: 0]
  ------------------
  281|      0|            fElement = new (fMemoryManager) QName(*element);
  282|      0|    }
  283|    918|    else
  284|    918|    {
  285|    918|        fElement = element;
  286|    918|    }
  287|    918|}
_ZN11xercesc_3_215ContentSpecNodeC2ENS0_9NodeTypesEPS0_S2_bbPNS_13MemoryManagerE:
  307|  1.56M|{
  308|  1.56M|}
_ZN11xercesc_3_215ContentSpecNodeC2EPNS_5QNameEPNS_13MemoryManagerE:
  238|  1.50M|{
  239|  1.50M|    if (element)
  ------------------
  |  Branch (239:9): [True: 1.50M, False: 0]
  ------------------
  240|  1.50M|        fElement = new (fMemoryManager) QName(*element);
  241|  1.50M|}

_ZN11xercesc_3_215DFAContentModelC2EbPNS_15ContentSpecNodeEPNS_13MemoryManagerE:
   88|  1.09k|{
   89|       |    // And build the DFA data structures
   90|  1.09k|    buildDFA(elemContentSpec);
   91|  1.09k|}
_ZN11xercesc_3_215DFAContentModelD2Ev:
  122|  1.09k|{
  123|       |    //
  124|       |    //  Clean up all the stuff that is not just temporary representation
  125|       |    //  data that was cleaned up after building the DFA.
  126|       |    //
  127|  1.09k|    fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
  128|       |
  129|  1.09k|    unsigned int index;
  130|  4.31M|    for (index = 0; index < fTransTableSize; index++)
  ------------------
  |  Branch (130:21): [True: 4.31M, False: 1.09k]
  ------------------
  131|  4.31M|        fMemoryManager->deallocate(fTransTable[index]); //delete [] fTransTable[index];
  132|  1.09k|    fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
  133|       |
  134|  1.09k|    if(fCountingStates)
  ------------------
  |  Branch (134:8): [True: 0, False: 1.09k]
  ------------------
  135|      0|    {
  136|      0|        for (unsigned int j = 0; j < fTransTableSize; ++j)
  ------------------
  |  Branch (136:34): [True: 0, False: 0]
  ------------------
  137|      0|            delete fCountingStates[j];
  138|      0|        fMemoryManager->deallocate(fCountingStates);
  139|      0|    }
  140|       |
  141|  1.32M|    for (index = 0; index < fLeafCount; index++)
  ------------------
  |  Branch (141:21): [True: 1.32M, False: 1.09k]
  ------------------
  142|  1.32M|        delete fElemMap[index];
  143|  1.09k|    fMemoryManager->deallocate(fElemMap); //delete [] fElemMap;
  144|       |
  145|  1.09k|    fMemoryManager->deallocate(fElemMapType); //delete [] fElemMapType;
  146|  1.09k|    fMemoryManager->deallocate(fLeafListType); //delete [] fLeafListType;
  147|       |
  148|  1.09k|    delete fLeafNameTypeVector;
  149|  1.09k|}
_ZNK11xercesc_3_215DFAContentModel15validateContentEPPNS_5QNameEmjPmPNS_13MemoryManagerE:
  161|  3.39k|{
  162|       |    //
  163|       |    //  If there are no children, then either we fail on the 0th element
  164|       |    //  or we return success. It depends upon whether this content model
  165|       |    //  accepts empty content, which we determined earlier.
  166|       |    //
  167|  3.39k|    if (!childCount)
  ------------------
  |  Branch (167:9): [True: 2.30k, False: 1.09k]
  ------------------
  168|  2.30k|    {
  169|       |        // success
  170|  2.30k|        if(fEmptyOk)
  ------------------
  |  Branch (170:12): [True: 591, False: 1.71k]
  ------------------
  171|    591|            return true;
  172|  1.71k|        *indexFailingChild=0;
  173|  1.71k|        return false;
  174|  2.30k|    }
  175|       |
  176|       |    //
  177|       |    //  Lets loop through the children in the array and move our way
  178|       |    //  through the states. Note that we use the fElemMap array to map
  179|       |    //  an element index to a state index.
  180|       |    //
  181|  1.09k|    unsigned int curState = 0;
  182|  1.09k|    unsigned int nextState = 0;
  183|  1.09k|    unsigned int loopCount = 0;
  184|  1.09k|    unsigned int childIndex = 0;
  185|  1.97k|    for (; childIndex < childCount; childIndex++)
  ------------------
  |  Branch (185:12): [True: 1.56k, False: 418]
  ------------------
  186|  1.56k|    {
  187|       |        // Get the current element index out
  188|  1.56k|        const QName* curElem = children[childIndex];
  189|  1.56k|        const XMLCh* curElemRawName = 0;
  190|  1.56k|        if (fDTD)
  ------------------
  |  Branch (190:13): [True: 1.56k, False: 0]
  ------------------
  191|  1.56k|            curElemRawName = curElem->getRawName();
  192|       |
  193|       |        // If this is text in a Schema mixed content model, skip it.
  194|  1.56k|        if ( fIsMixed &&
  ------------------
  |  Branch (194:14): [True: 0, False: 1.56k]
  ------------------
  195|  1.56k|            ( curElem->getURI() == XMLElementDecl::fgPCDataElemId))
  ------------------
  |  Branch (195:13): [True: 0, False: 0]
  ------------------
  196|      0|            continue;
  197|       |
  198|       |        // Look up this child in our element map
  199|  1.56k|        unsigned int elemIndex = 0;
  200|  4.02k|        for (; elemIndex < fElemMapSize; elemIndex++)
  ------------------
  |  Branch (200:16): [True: 3.35k, False: 674]
  ------------------
  201|  3.35k|        {
  202|  3.35k|            const QName* inElem  = fElemMap[elemIndex];
  203|  3.35k|            if (fDTD) {
  ------------------
  |  Branch (203:17): [True: 3.35k, False: 0]
  ------------------
  204|  3.35k|                if (XMLString::equals(inElem->getRawName(), curElemRawName)) {
  ------------------
  |  Branch (204:21): [True: 1.22k, False: 2.12k]
  ------------------
  205|  1.22k|                    nextState = fTransTable[curState][elemIndex];
  206|  1.22k|                    if (nextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (206:25): [True: 887, False: 340]
  ------------------
  207|    887|                        break;
  208|  1.22k|                }
  209|  3.35k|            }
  210|      0|            else {
  211|      0|                ContentSpecNode::NodeTypes type = fElemMapType[elemIndex];
  212|      0|                if (type == ContentSpecNode::Leaf)
  ------------------
  |  Branch (212:21): [True: 0, False: 0]
  ------------------
  213|      0|                {
  214|      0|                    if ((inElem->getURI() == curElem->getURI()) &&
  ------------------
  |  Branch (214:25): [True: 0, False: 0]
  ------------------
  215|      0|                    (XMLString::equals(inElem->getLocalPart(), curElem->getLocalPart()))) {
  ------------------
  |  Branch (215:21): [True: 0, False: 0]
  ------------------
  216|      0|                        nextState = fTransTable[curState][elemIndex];
  217|      0|                        if (nextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (217:29): [True: 0, False: 0]
  ------------------
  218|      0|                            break;
  219|      0|                    }
  220|      0|                }
  221|      0|                else if ((type & 0x0f)== ContentSpecNode::Any)
  ------------------
  |  Branch (221:26): [True: 0, False: 0]
  ------------------
  222|      0|                {
  223|      0|                    nextState = fTransTable[curState][elemIndex];
  224|      0|                    if (nextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (224:25): [True: 0, False: 0]
  ------------------
  225|      0|                        break;
  226|      0|                }
  227|      0|                else if ((type & 0x0f) == ContentSpecNode::Any_NS)
  ------------------
  |  Branch (227:26): [True: 0, False: 0]
  ------------------
  228|      0|                {
  229|      0|                    if (inElem->getURI() == curElem->getURI())
  ------------------
  |  Branch (229:25): [True: 0, False: 0]
  ------------------
  230|      0|                    {
  231|      0|                        nextState = fTransTable[curState][elemIndex];
  232|      0|                        if (nextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (232:29): [True: 0, False: 0]
  ------------------
  233|      0|                            break;
  234|      0|                    }
  235|      0|                }
  236|      0|                else if ((type & 0x0f) == ContentSpecNode::Any_Other)
  ------------------
  |  Branch (236:26): [True: 0, False: 0]
  ------------------
  237|      0|                {
  238|       |                    // Here we assume that empty string has id 1.
  239|       |                    //
  240|      0|                    unsigned int uriId = curElem->getURI();
  241|      0|                    if (uriId != 1 && uriId != inElem->getURI()) {
  ------------------
  |  Branch (241:25): [True: 0, False: 0]
  |  Branch (241:39): [True: 0, False: 0]
  ------------------
  242|      0|                        nextState = fTransTable[curState][elemIndex];
  243|      0|                        if (nextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (243:29): [True: 0, False: 0]
  ------------------
  244|      0|                            break;
  245|      0|                    }
  246|      0|                }
  247|      0|            }
  248|  3.35k|        }//for elemIndex
  249|       |
  250|       |        // If "nextState" is -1, we found a match, but the transition is invalid
  251|  1.56k|        if (nextState == XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (251:13): [True: 340, False: 1.22k]
  ------------------
  252|    340|        {
  253|    340|            *indexFailingChild=childIndex;
  254|    340|            return false;
  255|    340|        }
  256|       |
  257|       |        // If we didn't find it, then obviously not valid
  258|  1.22k|        if (elemIndex == fElemMapSize)
  ------------------
  |  Branch (258:13): [True: 334, False: 887]
  ------------------
  259|    334|        {
  260|    334|            *indexFailingChild=childIndex;
  261|    334|            return false;
  262|    334|        }
  263|       |
  264|    887|        unsigned int nextLoop = 0;
  265|    887|        if(!handleRepetitions(curElem, curState, loopCount, nextState, nextLoop, elemIndex, 0))
  ------------------
  |  Branch (265:12): [True: 0, False: 887]
  ------------------
  266|      0|        {
  267|      0|            *indexFailingChild=childIndex;
  268|      0|            return false;
  269|      0|        }
  270|       |
  271|    887|        curState = nextState;
  272|    887|        loopCount = nextLoop;
  273|    887|        nextState = 0;
  274|       |
  275|    887|    }//for childIndex
  276|       |
  277|       |    //
  278|       |    //  We transitioned all the way through the input list. However, that
  279|       |    //  does not mean that we ended in a final state. So check whether
  280|       |    //  our ending state is a final state.
  281|       |    //
  282|    418|    if (!fFinalStateFlags[curState])
  ------------------
  |  Branch (282:9): [True: 254, False: 164]
  ------------------
  283|    254|    {
  284|    254|        *indexFailingChild=childIndex;
  285|    254|        return false;
  286|    254|    }
  287|       |
  288|       |    // verify if we exited before the minOccurs was satisfied
  289|    164|    if (fCountingStates != 0) {
  ------------------
  |  Branch (289:9): [True: 0, False: 164]
  ------------------
  290|      0|        Occurence* o = fCountingStates[curState];
  291|      0|        if (o != 0 && loopCount < (unsigned int)o->minOccurs) {
  ------------------
  |  Branch (291:13): [True: 0, False: 0]
  |  Branch (291:23): [True: 0, False: 0]
  ------------------
  292|       |            // not enough loops on the current state to be considered final.
  293|      0|            *indexFailingChild=childIndex;
  294|      0|            return false;
  295|      0|        }
  296|      0|    }
  297|       |
  298|       |    //success
  299|    164|    return true;
  300|    164|}
_ZNK11xercesc_3_215DFAContentModel17handleRepetitionsEPKNS_5QNameEjjRjS4_mPNS_27SubstitutionGroupComparatorE:
  446|    887|{
  447|    887|    nextLoop = 0;
  448|    887|    if (fCountingStates != 0) {
  ------------------
  |  Branch (448:9): [True: 0, False: 887]
  ------------------
  449|      0|        nextLoop = currentLoop;
  450|      0|        Occurence* o = fCountingStates[curState];
  451|      0|        if (o != 0) {
  ------------------
  |  Branch (451:13): [True: 0, False: 0]
  ------------------
  452|      0|            if (curState == nextState) {
  ------------------
  |  Branch (452:17): [True: 0, False: 0]
  ------------------
  453|      0|                if (++nextLoop > (unsigned int)o->maxOccurs && o->maxOccurs != -1) {
  ------------------
  |  Branch (453:21): [True: 0, False: 0]
  |  Branch (453:64): [True: 0, False: 0]
  ------------------
  454|       |                    // It's likely that we looped too many times on the current state
  455|       |                    // however it's possible that we actually matched another particle
  456|       |                    // which allows the same name.
  457|       |                    //
  458|       |                    // Consider:
  459|       |                    //
  460|       |                    // <xs:sequence>
  461|       |                    //  <xs:element name="foo" type="xs:string" minOccurs="3" maxOccurs="3"/>
  462|       |                    //  <xs:element name="foo" type="xs:string" fixed="bar"/>
  463|       |                    // </xs:sequence>
  464|       |                    //
  465|       |                    // and
  466|       |                    //
  467|       |                    // <xs:sequence>
  468|       |                    //  <xs:element name="foo" type="xs:string" minOccurs="3" maxOccurs="3"/>
  469|       |                    //  <xs:any namespace="##any" processContents="skip"/>
  470|       |                    // </xs:sequence>
  471|       |                    //
  472|       |                    // In the DFA there will be two transitions from the current state which
  473|       |                    // allow "foo". Note that this is not a UPA violation. The ambiguity of which
  474|       |                    // transition to take is resolved by the current value of the counter. Since
  475|       |                    // we've already seen enough instances of the first "foo" perhaps there is
  476|       |                    // another element declaration or wildcard deeper in the element map which
  477|       |                    // matches.
  478|      0|                    unsigned int tempNextState = 0;
  479|       |
  480|      0|                    while (++elemIndex < fElemMapSize) {
  ------------------
  |  Branch (480:28): [True: 0, False: 0]
  ------------------
  481|      0|                        QName* inElem  = fElemMap[elemIndex];
  482|      0|                        ContentSpecNode::NodeTypes type = fElemMapType[elemIndex];
  483|      0|                        if (type == ContentSpecNode::Leaf)
  ------------------
  |  Branch (483:29): [True: 0, False: 0]
  ------------------
  484|      0|                        {
  485|      0|                            if(comparator!=0) {
  ------------------
  |  Branch (485:32): [True: 0, False: 0]
  ------------------
  486|      0|                                if (comparator->isEquivalentTo(curElem, inElem) )
  ------------------
  |  Branch (486:37): [True: 0, False: 0]
  ------------------
  487|      0|                                {
  488|      0|                                    tempNextState = fTransTable[curState][elemIndex];
  489|      0|                                    if (tempNextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (489:41): [True: 0, False: 0]
  ------------------
  490|      0|                                        break;
  491|      0|                                }
  492|      0|                            }
  493|      0|                            else if (fDTD) {
  ------------------
  |  Branch (493:38): [True: 0, False: 0]
  ------------------
  494|      0|                                if (XMLString::equals(inElem->getRawName(), curElem->getRawName())) {
  ------------------
  |  Branch (494:37): [True: 0, False: 0]
  ------------------
  495|      0|                                    tempNextState = fTransTable[curState][elemIndex];
  496|      0|                                    if (tempNextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (496:41): [True: 0, False: 0]
  ------------------
  497|      0|                                        break;
  498|      0|                                }
  499|      0|                            }
  500|      0|                            else {
  501|      0|                                if ((inElem->getURI() == curElem->getURI()) &&
  ------------------
  |  Branch (501:37): [True: 0, False: 0]
  ------------------
  502|      0|                                (XMLString::equals(inElem->getLocalPart(), curElem->getLocalPart()))) {
  ------------------
  |  Branch (502:33): [True: 0, False: 0]
  ------------------
  503|      0|                                    tempNextState = fTransTable[curState][elemIndex];
  504|      0|                                    if (tempNextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (504:41): [True: 0, False: 0]
  ------------------
  505|      0|                                        break;
  506|      0|                                }
  507|      0|                            }
  508|      0|                        }
  509|      0|                        else if ((type & 0x0f)== ContentSpecNode::Any)
  ------------------
  |  Branch (509:34): [True: 0, False: 0]
  ------------------
  510|      0|                        {
  511|      0|                            tempNextState = fTransTable[curState][elemIndex];
  512|      0|                            if (tempNextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (512:33): [True: 0, False: 0]
  ------------------
  513|      0|                                break;
  514|      0|                        }
  515|      0|                        else if ((type & 0x0f) == ContentSpecNode::Any_NS)
  ------------------
  |  Branch (515:34): [True: 0, False: 0]
  ------------------
  516|      0|                        {
  517|      0|                            if (inElem->getURI() == curElem->getURI())
  ------------------
  |  Branch (517:33): [True: 0, False: 0]
  ------------------
  518|      0|                            {
  519|      0|                                tempNextState = fTransTable[curState][elemIndex];
  520|      0|                                if (tempNextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (520:37): [True: 0, False: 0]
  ------------------
  521|      0|                                    break;
  522|      0|                            }
  523|      0|                        }
  524|      0|                        else if ((type & 0x0f) == ContentSpecNode::Any_Other)
  ------------------
  |  Branch (524:34): [True: 0, False: 0]
  ------------------
  525|      0|                        {
  526|       |                            // Here we assume that empty string has id 1.
  527|       |                            //
  528|      0|                            unsigned int uriId = curElem->getURI();
  529|      0|                            if (uriId != 1 && uriId != inElem->getURI())
  ------------------
  |  Branch (529:33): [True: 0, False: 0]
  |  Branch (529:47): [True: 0, False: 0]
  ------------------
  530|      0|                            {
  531|      0|                                tempNextState = fTransTable[curState][elemIndex];
  532|      0|                                if (tempNextState != XMLContentModel::gInvalidTrans)
  ------------------
  |  Branch (532:37): [True: 0, False: 0]
  ------------------
  533|      0|                                    break;
  534|      0|                            }
  535|      0|                        }
  536|      0|                    }
  537|       |
  538|       |                    // if we still can't find a match, report the error
  539|      0|                    if (elemIndex == fElemMapSize)
  ------------------
  |  Branch (539:25): [True: 0, False: 0]
  ------------------
  540|      0|                        return false;
  541|       |
  542|       |                    // if we found a match, set the next state and reset the
  543|       |                    // counter if the next state is a counting state.
  544|      0|                    nextState = tempNextState;
  545|      0|                    Occurence* o = fCountingStates[nextState];
  546|      0|                    if (o != 0) {
  ------------------
  |  Branch (546:25): [True: 0, False: 0]
  ------------------
  547|      0|                      nextLoop = (elemIndex == XMLSize_t (o->elemIndex)) ? 1 : 0;
  ------------------
  |  Branch (547:34): [True: 0, False: 0]
  ------------------
  548|      0|                    }
  549|      0|                }
  550|      0|            }
  551|      0|            else if (nextLoop < (unsigned int)o->minOccurs) {
  ------------------
  |  Branch (551:22): [True: 0, False: 0]
  ------------------
  552|       |                // not enough loops on the current state.
  553|      0|                return false;
  554|      0|            }
  555|      0|            else {
  556|       |                // Exiting a counting state. If we're entering a new
  557|       |                // counting state, reset the counter.
  558|      0|                o = fCountingStates[nextState];
  559|      0|                if (o != 0) {
  ------------------
  |  Branch (559:21): [True: 0, False: 0]
  ------------------
  560|      0|                  nextLoop = (elemIndex == XMLSize_t (o->elemIndex)) ? 1 : 0;
  ------------------
  |  Branch (560:30): [True: 0, False: 0]
  ------------------
  561|      0|                }
  562|      0|            }
  563|      0|        }
  564|      0|        else {
  565|      0|            o = fCountingStates[nextState];
  566|      0|            if (o != 0) {
  ------------------
  |  Branch (566:17): [True: 0, False: 0]
  ------------------
  567|       |                // Entering a new counting state. Reset the counter.
  568|       |                // If we've already seen one instance of the looping
  569|       |                // particle set the counter to 1, otherwise set it
  570|       |                // to 0.
  571|      0|              nextLoop = (elemIndex == XMLSize_t (o->elemIndex)) ? 1 : 0;
  ------------------
  |  Branch (571:26): [True: 0, False: 0]
  ------------------
  572|      0|            }
  573|      0|        }
  574|      0|    }
  575|    887|    return true;
  576|    887|}
_ZN11xercesc_3_215DFAContentModel8buildDFAEPNS_15ContentSpecNodeE:
  582|  1.09k|{
  583|  1.09k|    unsigned int index;
  584|       |
  585|       |    //
  586|       |    //  The first step we need to take is to rewrite the content model using
  587|       |    //  our CMNode objects, and in the process get rid of any repetition short
  588|       |    //  cuts, converting them into '*' style repetitions or getting rid of
  589|       |    //  repetitions altogether.
  590|       |    //
  591|       |    //  The conversions done are:
  592|       |    //
  593|       |    //  x+ -> (x|x*)
  594|       |    //  x? -> (x|epsilon)
  595|       |    //
  596|       |    //  This is a relatively complex scenario. What is happening is that we
  597|       |    //  create a top level binary node of which the special EOC value is set
  598|       |    //  as the right side node. The the left side is set to the rewritten
  599|       |    //  syntax tree. The source is the original content model info from the
  600|       |    //  decl pool. The rewrite is done by buildSyntaxTree() which recurses the
  601|       |    //  decl pool's content of the element and builds a new tree in the
  602|       |    //  process.
  603|       |    //
  604|       |    //  Note that, during this operation, we set each non-epsilon leaf node's
  605|       |    //  DFA state position and count the number of such leafs, which is left
  606|       |    //  in the fLeafCount member.
  607|       |    //
  608|  1.09k|    fLeafCount=countLeafNodes(curNode);
  609|  1.09k|    fEOCPos = fLeafCount++;
  610|       |
  611|       |    //  We need to build an array of references to the non-epsilon
  612|       |    //  leaf nodes. We will put them in the array according to their position values
  613|       |    //
  614|  1.09k|    fLeafList = (CMLeaf**) fMemoryManager->allocate(fLeafCount*sizeof(CMLeaf*)); //new CMLeaf*[fLeafCount];
  615|  1.09k|    fLeafListType = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
  616|  1.09k|    (
  617|  1.09k|        fLeafCount * sizeof(ContentSpecNode::NodeTypes)
  618|  1.09k|    ); //new ContentSpecNode::NodeTypes[fLeafCount];
  619|       |    //
  620|       |    //  And, moving onward... We now need to build the follow position sets
  621|       |    //  for all the nodes. So we allocate an array of pointers to state sets,
  622|       |    //  one for each leaf node (i.e. each significant DFA position.)
  623|       |    //
  624|  1.09k|    fFollowList = (CMStateSet**) fMemoryManager->allocate
  625|  1.09k|    (
  626|  1.09k|        fLeafCount * sizeof(CMStateSet*)
  627|  1.09k|    ); //new CMStateSet*[fLeafCount];
  628|  1.32M|    for (index = 0; index < fLeafCount; index++)
  ------------------
  |  Branch (628:21): [True: 1.32M, False: 1.09k]
  ------------------
  629|  1.32M|        fFollowList[index] = new (fMemoryManager) CMStateSet(fLeafCount, fMemoryManager);
  630|       |
  631|       |    //  The buildSyntaxTree function will recursively iterate over the ContentSpecNode
  632|       |    //  and build the CMNode hierarchy; it will also put every leaf node in the fLeafList
  633|       |    //  array, then calculate the first and last position sets of each node. This is
  634|       |    //  cached away in each of the nodes.
  635|       |    //
  636|       |    //  Along the way we also set the leaf count in each node as the maximum
  637|       |    //  state count. They must know this in order to create their first/last
  638|       |    //  position sets.
  639|       |    //
  640|  1.09k|    unsigned int counter=0;
  641|  1.09k|    CMNode* nodeOrgContent = buildSyntaxTree(curNode, counter);
  642|       |    //
  643|       |    //  Check to see whether this content model can handle an empty content,
  644|       |    //  which is something we need to optimize by looking now before we
  645|       |    //  throw away the info that would tell us that.
  646|       |    //
  647|       |    //  If the left node of the head (the top level of the original content)
  648|       |    //  is nullable, then its true.
  649|       |    //
  650|  1.09k|    fEmptyOk = nodeOrgContent->isNullable();
  651|       |
  652|       |    //
  653|       |    //  And handle specially the EOC node, which also must be numbered and
  654|       |    //  counted as a non-epsilon leaf node. It could not be handled in the
  655|       |    //  above tree build because it was created before all that started. We
  656|       |    //  save the EOC position since its used during the DFA building loop.
  657|       |    //
  658|  1.09k|    CMLeaf* nodeEOC = new (fMemoryManager) CMLeaf
  659|  1.09k|    (
  660|  1.09k|        new (fMemoryManager) QName
  661|  1.09k|        (
  662|  1.09k|            XMLUni::fgZeroLenString
  663|  1.09k|            , XMLUni::fgZeroLenString
  664|  1.09k|            , XMLContentModel::gEOCFakeId
  665|  1.09k|            , fMemoryManager
  666|  1.09k|        )
  667|  1.09k|        , fEOCPos
  668|  1.09k|        , true
  669|  1.09k|        , fLeafCount
  670|  1.09k|        , fMemoryManager
  671|  1.09k|    );
  672|  1.09k|    fHeadNode = new (fMemoryManager) CMBinaryOp
  673|  1.09k|    (
  674|  1.09k|        ContentSpecNode::Sequence
  675|  1.09k|        , nodeOrgContent
  676|  1.09k|        , nodeEOC
  677|  1.09k|        , fLeafCount
  678|  1.09k|        , fMemoryManager
  679|  1.09k|    );
  680|       |
  681|       |    //  Put also the final EOC node in the leaf array
  682|  1.09k|    fLeafList[counter] = new (fMemoryManager) CMLeaf
  683|  1.09k|    (
  684|  1.09k|        nodeEOC->getElement()
  685|  1.09k|        , nodeEOC->getPosition()
  686|  1.09k|        , fLeafCount
  687|  1.09k|        , fMemoryManager
  688|  1.09k|    );
  689|  1.09k|    fLeafListType[counter] = ContentSpecNode::Leaf;
  690|       |
  691|       |    //
  692|       |    //  Now handle our top level. We use our left child's last pos set and our
  693|       |    //  right child's first pos set, so get them now for convenience.
  694|       |    //
  695|  1.09k|    const CMStateSet& last  = nodeOrgContent->getLastPos();
  696|  1.09k|    const CMStateSet& first = nodeEOC->getFirstPos();
  697|       |
  698|       |    //
  699|       |    //  Now, for every position which is in our left child's last set
  700|       |    //  add all of the states in our right child's first set to the
  701|       |    //  follow set for that position.
  702|       |    //
  703|  1.09k|    CMStateSetEnumerator enumLast(&last);
  704|   378k|    while(enumLast.hasMoreElements())
  ------------------
  |  Branch (704:11): [True: 377k, False: 1.09k]
  ------------------
  705|   377k|    {
  706|   377k|        XMLSize_t index=enumLast.nextElement();
  707|   377k|        *fFollowList[index] |= first;
  708|   377k|    }
  709|       |
  710|       |    //
  711|       |    //  And finally the big push... Now we build the DFA using all the states
  712|       |    //  and the tree we've built up. First we set up the various data
  713|       |    //  structures we are going to use while we do this.
  714|       |    //
  715|       |    //  First of all we need an array of unique element ids in our content
  716|       |    //  model. For each transition table entry, we need a set of contiguous
  717|       |    //  indices to represent the transitions for a particular input element.
  718|       |    //  So we need to a zero based range of indexes that map to element types.
  719|       |    //  This element map provides that mapping.
  720|       |    //
  721|  1.09k|    fElemMap = (QName**) fMemoryManager->allocate
  722|  1.09k|    (
  723|  1.09k|        fLeafCount * sizeof(QName*)
  724|  1.09k|    ); //new QName*[fLeafCount];
  725|  1.09k|    fElemMapType = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
  726|  1.09k|    (
  727|  1.09k|        fLeafCount * sizeof(ContentSpecNode::NodeTypes)
  728|  1.09k|    ); //new ContentSpecNode::NodeTypes[fLeafCount];
  729|  1.09k|    fElemMapSize = 0;
  730|       |
  731|  1.09k|    Occurence** elemOccurenceMap=0;
  732|  1.32M|    for (unsigned int outIndex = 0; outIndex < fLeafCount; outIndex++)
  ------------------
  |  Branch (732:37): [True: 1.32M, False: 1.09k]
  ------------------
  733|  1.32M|    {
  734|  1.32M|        fElemMap[outIndex] = new (fMemoryManager) QName(fMemoryManager);
  735|       |
  736|  1.32M|        if ( (fLeafListType[outIndex] & 0x0f) != ContentSpecNode::Leaf )
  ------------------
  |  Branch (736:14): [True: 0, False: 1.32M]
  ------------------
  737|      0|            if (!fLeafNameTypeVector)
  ------------------
  |  Branch (737:17): [True: 0, False: 0]
  ------------------
  738|      0|                fLeafNameTypeVector = new (fMemoryManager) ContentLeafNameTypeVector(fMemoryManager);
  739|       |
  740|       |        // Get the current leaf's element index
  741|  1.32M|        CMLeaf* leaf=fLeafList[outIndex];
  742|  1.32M|        const QName* element = leaf->getElement();
  743|  1.32M|        const XMLCh* elementRawName = 0;
  744|  1.32M|        if (fDTD && element)
  ------------------
  |  Branch (744:13): [True: 1.32M, False: 0]
  |  Branch (744:21): [True: 1.32M, False: 0]
  ------------------
  745|  1.32M|            elementRawName = element->getRawName();
  746|       |
  747|       |        // See if the current leaf node's element index is in the list
  748|  1.32M|        unsigned int inIndex = 0;
  749|       |
  750|  15.6M|        for (; inIndex < fElemMapSize; inIndex++)
  ------------------
  |  Branch (750:16): [True: 15.6M, False: 31.3k]
  ------------------
  751|  15.6M|        {
  752|  15.6M|            const QName* inElem = fElemMap[inIndex];
  753|  15.6M|            if (fDTD) {
  ------------------
  |  Branch (753:17): [True: 15.6M, False: 0]
  ------------------
  754|  15.6M|                if (XMLString::equals(inElem->getRawName(), elementRawName)) {
  ------------------
  |  Branch (754:21): [True: 1.29M, False: 14.3M]
  ------------------
  755|  1.29M|                    break;
  756|  1.29M|                }
  757|  15.6M|            }
  758|      0|            else {
  759|      0|                if ((fElemMapType[inIndex] == fLeafListType[outIndex]) &&
  ------------------
  |  Branch (759:21): [True: 0, False: 0]
  ------------------
  760|      0|                    (inElem->getURI() == element->getURI()) &&
  ------------------
  |  Branch (760:21): [True: 0, False: 0]
  ------------------
  761|      0|                    (XMLString::equals(inElem->getLocalPart(), element->getLocalPart()))) {
  ------------------
  |  Branch (761:21): [True: 0, False: 0]
  ------------------
  762|      0|                    break;
  763|      0|                }
  764|      0|            }
  765|  15.6M|        }
  766|       |
  767|       |        // If it was not in the list, then add it and bump the map size
  768|  1.32M|        if (inIndex == fElemMapSize)
  ------------------
  |  Branch (768:13): [True: 31.3k, False: 1.29M]
  ------------------
  769|  31.3k|        {
  770|  31.3k|            fElemMap[fElemMapSize]->setValues(*element);
  771|  31.3k|            if(leaf->isRepeatableLeaf())
  ------------------
  |  Branch (771:16): [True: 0, False: 31.3k]
  ------------------
  772|      0|            {
  773|      0|                if (elemOccurenceMap == 0) {
  ------------------
  |  Branch (773:21): [True: 0, False: 0]
  ------------------
  774|      0|                    elemOccurenceMap = (Occurence**)fMemoryManager->allocate(fLeafCount*sizeof(Occurence*));
  775|      0|                    memset(elemOccurenceMap, 0, fLeafCount*sizeof(Occurence*));
  776|      0|                }
  777|      0|                elemOccurenceMap[fElemMapSize] = new (fMemoryManager) Occurence(((CMRepeatingLeaf*)leaf)->getMinOccurs(), ((CMRepeatingLeaf*)leaf)->getMaxOccurs(), fElemMapSize);
  778|      0|            }
  779|  31.3k|            fElemMapType[fElemMapSize] = fLeafListType[outIndex];
  780|  31.3k|            ++fElemMapSize;
  781|  31.3k|        }
  782|  1.32M|    }
  783|       |
  784|       |    // set up the fLeafNameTypeVector object if there is one.
  785|  1.09k|    if (fLeafNameTypeVector) {
  ------------------
  |  Branch (785:9): [True: 0, False: 1.09k]
  ------------------
  786|      0|        fLeafNameTypeVector->setValues(fElemMap, fElemMapType, fElemMapSize);
  787|      0|    }
  788|       |
  789|       |    /***
  790|       |     * Optimization(Jan, 2001); We sort fLeafList according to
  791|       |     * elemIndex which is *uniquely* associated to each leaf.
  792|       |     * We are *assuming* that each element appears in at least one leaf.
  793|       |     **/
  794|       |    // don't forget to delete it
  795|       |#ifdef OPTIMIZED_BUT_STILL_LINEAR_SEARCH
  796|       |    int *fLeafSorter = (int*) fMemoryManager->allocate
  797|       |    (
  798|       |        (fLeafCount + fElemMapSize) * sizeof(int)
  799|       |    ); //new int[fLeafCount + fElemMapSize];
  800|       |    unsigned int fSortCount = 0;
  801|       |
  802|       |    for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
  803|       |    {
  804|       |        const QName* element = fElemMap[elemIndex];
  805|       |        const XMLCh* elementRawName = 0;
  806|       |        if (fDTD && element)
  807|       |            elementRawName = element->getRawName();
  808|       |
  809|       |        for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
  810|       |        {
  811|       |            const QName* leaf = fLeafList[leafIndex]->getElement();
  812|       |            if (fDTD) {
  813|       |                if (XMLString::equals(leaf->getRawName(), elementRawName)) {
  814|       |                    fLeafSorter[fSortCount++] = leafIndex;
  815|       |                }
  816|       |            }
  817|       |            else {
  818|       |                if ((fElemMapType[elemIndex] == fLeafListType[leafIndex]) &&
  819|       |                    (leaf->getURI() == element->getURI()) &&
  820|       |                    (XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
  821|       |                      fLeafSorter[fSortCount++] = leafIndex;
  822|       |                }
  823|       |            }
  824|       |        }
  825|       |        fLeafSorter[fSortCount++] = -1;
  826|       |    }
  827|       |#endif
  828|       |
  829|       |    // instead of using a single array with -1 to separate elements, use a bidimensional map
  830|  1.09k|    unsigned int** fLeafSorter = (unsigned int**)fMemoryManager->allocate(fElemMapSize * sizeof(unsigned int*));
  831|  1.09k|    unsigned int* tmpSorter = (unsigned int*)fMemoryManager->allocate(fLeafCount * sizeof(unsigned int));
  832|  32.4k|    for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
  ------------------
  |  Branch (832:38): [True: 31.3k, False: 1.09k]
  ------------------
  833|  31.3k|    {
  834|  31.3k|        const QName* element = fElemMap[elemIndex];
  835|  31.3k|        const XMLCh* elementRawName = 0;
  836|  31.3k|        if (fDTD && element)
  ------------------
  |  Branch (836:13): [True: 31.3k, False: 0]
  |  Branch (836:21): [True: 31.3k, False: 0]
  ------------------
  837|  31.3k|            elementRawName = element->getRawName();
  838|       |
  839|  31.3k|        unsigned int fSortCount=0;
  840|   124M|        for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
  ------------------
  |  Branch (840:42): [True: 124M, False: 31.3k]
  ------------------
  841|   124M|        {
  842|   124M|            const QName* leaf = fLeafList[leafIndex]->getElement();
  843|   124M|            if (fDTD) {
  ------------------
  |  Branch (843:17): [True: 124M, False: 0]
  ------------------
  844|   124M|                if (XMLString::equals(leaf->getRawName(), elementRawName)) {
  ------------------
  |  Branch (844:21): [True: 1.32M, False: 122M]
  ------------------
  845|  1.32M|                    tmpSorter[fSortCount++] = leafIndex;
  846|  1.32M|                }
  847|   124M|            }
  848|      0|            else {
  849|      0|                if ((fElemMapType[elemIndex] == fLeafListType[leafIndex]) &&
  ------------------
  |  Branch (849:21): [True: 0, False: 0]
  ------------------
  850|      0|                    (leaf->getURI() == element->getURI()) &&
  ------------------
  |  Branch (850:21): [True: 0, False: 0]
  ------------------
  851|      0|                    (XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
  ------------------
  |  Branch (851:21): [True: 0, False: 0]
  ------------------
  852|      0|                      tmpSorter[fSortCount++] = leafIndex;
  853|      0|                }
  854|      0|            }
  855|   124M|        }
  856|       |
  857|  31.3k|        fLeafSorter[elemIndex]=(unsigned int*)fMemoryManager->allocate((fSortCount+1) * sizeof(unsigned int));
  858|  31.3k|        fLeafSorter[elemIndex][0]=fSortCount;
  859|  1.35M|        for (unsigned int index=0;index<fSortCount;index++)
  ------------------
  |  Branch (859:35): [True: 1.32M, False: 31.3k]
  ------------------
  860|  1.32M|            fLeafSorter[elemIndex][index+1]=tmpSorter[index];
  861|  31.3k|    }
  862|  1.09k|    fMemoryManager->deallocate(tmpSorter);
  863|       |
  864|       |    //
  865|       |    //  Next lets create some arrays, some that that hold transient info
  866|       |    //  during the DFA build and some that are permament. These are kind of
  867|       |    //  sticky since we cannot know how big they will get, but we don't want
  868|       |    //  to use any collection type classes because of performance.
  869|       |    //
  870|       |    //  Basically they will probably be about fLeafCount*2 on average, but can
  871|       |    //  be as large as 2^(fLeafCount*2), worst case. So we start with
  872|       |    //  fLeafCount*4 as a middle ground. This will be very unlikely to ever
  873|       |    //  have to expand though, it if does, the overhead will be somewhat ugly.
  874|       |    //
  875|  1.09k|    unsigned int curArraySize = fLeafCount * 4;
  876|  1.09k|    CMStateSet** statesToDo = (CMStateSet**)
  877|  1.09k|        fMemoryManager->allocate
  878|  1.09k|        (
  879|  1.09k|            curArraySize * sizeof(CMStateSet*)
  880|  1.09k|        ); //new const CMStateSet*[curArraySize];
  881|  1.09k|    fFinalStateFlags = (bool*) fMemoryManager->allocate
  882|  1.09k|    (
  883|  1.09k|        curArraySize * sizeof(bool)
  884|  1.09k|    ); //new bool[curArraySize];
  885|  1.09k|    fTransTable = (unsigned int**) fMemoryManager->allocate
  886|  1.09k|    (
  887|  1.09k|        curArraySize * sizeof(unsigned int*)
  888|  1.09k|    ); //new unsigned int*[curArraySize];
  889|       |
  890|       |    //
  891|       |    //  Ok we start with the initial set as the first pos set of the head node
  892|       |    //  (which is the seq node that holds the content model and the EOC node.)
  893|       |    //
  894|  1.09k|    CMStateSet* setT = new (fMemoryManager) CMStateSet(fHeadNode->getFirstPos());
  895|       |
  896|       |    //
  897|       |    // Note on memory leak: Bugzilla#2707:
  898|       |    // ===================================
  899|       |    // The CMBinary, pointed to by fHeadNode, shall be released by
  900|       |    // deleted by itself.
  901|       |    //
  902|       |    // fLeafList[] maintains its **OWN** copy of CMLeaf to avoid double deletion
  903|       |    // of CMLeaf.
  904|       |    //
  905|       |
  906|  1.09k|    delete fHeadNode;
  907|       |
  908|       |    //
  909|       |    //  Init our two state flags. Basically the unmarked state counter is
  910|       |    //  always chasing the current state counter. When it catches up, that
  911|       |    //  means we made a pass through that did not add any new states to the
  912|       |    //  lists, at which time we are done. We could have used a expanding array
  913|       |    //  of flags which we used to mark off states as we complete them, but
  914|       |    //  this is easier though less readable maybe.
  915|       |    //
  916|  1.09k|    unsigned int unmarkedState = 0;
  917|  1.09k|    unsigned int curState = 0;
  918|       |
  919|       |    //
  920|       |    //  Init the first transition table entry, and put the initial state
  921|       |    //  into the states to do list, then bump the current state.
  922|       |    //
  923|  1.09k|    fTransTable[curState] = makeDefStateList();
  924|  1.09k|    statesToDo[curState] = setT;
  925|  1.09k|    curState++;
  926|       |
  927|       |    //
  928|       |    // the stateTable is an auxiliary means to fast
  929|       |    // identification of new state created (instead
  930|       |    // of sequential loop statesToDo to find out),
  931|       |    // while the role that statesToDo plays remain unchanged.
  932|       |    //
  933|  1.09k|    RefHashTableOf<XMLInteger, CMStateSetHasher> *stateTable =
  934|  1.09k|        new (fMemoryManager) RefHashTableOf<XMLInteger, CMStateSetHasher>
  935|  1.09k|        (
  936|  1.09k|            curArraySize
  937|  1.09k|            , true
  938|  1.09k|            , fMemoryManager
  939|  1.09k|        );
  940|       |    //stateTable->put((CMStateSet*)setT, new (fMemoryManager) XMLInteger(0));
  941|       |
  942|       |    //
  943|       |    //  Ok, almost done with the algorithm from hell... We now enter the
  944|       |    //  loop where we go until the states done counter catches up with
  945|       |    //  the states to do counter.
  946|       |    //
  947|  1.09k|    CMStateSet* newSet = 0;
  948|  4.31M|    while (unmarkedState < curState)
  ------------------
  |  Branch (948:12): [True: 4.31M, False: 1.09k]
  ------------------
  949|  4.31M|    {
  950|       |        //
  951|       |        //  Get the next unmarked state out of the list of states to do.
  952|       |        //  And get the associated transition table entry.
  953|       |        //
  954|  4.31M|        setT = statesToDo[unmarkedState];
  955|  4.31M|        unsigned int* transEntry = fTransTable[unmarkedState];
  956|       |
  957|       |        // Mark this one final if it contains the EOC state
  958|  4.31M|        fFinalStateFlags[unmarkedState] = setT->getBit(fEOCPos);
  959|       |
  960|       |        // Bump up the unmarked state count, marking this state done
  961|  4.31M|        unmarkedState++;
  962|       |
  963|       |#ifdef OPTIMIZED_BUT_STILL_LINEAR_SEARCH
  964|       |        // Optimization(Jan, 2001)
  965|       |        unsigned int sorterIndex = 0;
  966|       |        // Optimization(Jan, 2001)
  967|       |#endif
  968|       |
  969|       |        // Loop through each possible input symbol in the element map
  970|   106M|        for (unsigned int elemIndex = 0; elemIndex < fElemMapSize; elemIndex++)
  ------------------
  |  Branch (970:42): [True: 101M, False: 4.31M]
  ------------------
  971|   101M|        {
  972|       |            //
  973|       |            //  Build up a set of states which is the union of all of the
  974|       |            //  follow sets of DFA positions that are in the current state. If
  975|       |            //  we gave away the new set last time through then create a new
  976|       |            //  one. Otherwise, zero out the existing one.
  977|       |            //
  978|   101M|            if (!newSet)
  ------------------
  |  Branch (978:17): [True: 4.31M, False: 97.4M]
  ------------------
  979|  4.31M|                newSet = new (fMemoryManager) CMStateSet
  980|  4.31M|                (
  981|  4.31M|                    fLeafCount
  982|  4.31M|                    , fMemoryManager
  983|  4.31M|                );
  984|  97.4M|            else
  985|  97.4M|                newSet->zeroBits();
  986|       |
  987|       |#ifdef OBSOLETED
  988|       |// unoptimized code
  989|       |            for (unsigned int leafIndex = 0; leafIndex < fLeafCount; leafIndex++)
  990|       |            {
  991|       |                // If this leaf index (DFA position) is in the current set...
  992|       |                if (setT->getBit(leafIndex))
  993|       |                {
  994|       |                    //
  995|       |                    //  If this leaf is the current input symbol, then we want
  996|       |                    //  to add its follow list to the set of states to transition
  997|       |                    //  to from the current state.
  998|       |                    //
  999|       |                    const QName* leaf = fLeafList[leafIndex]->getElement();
 1000|       |                    const QName* element = fElemMap[elemIndex];
 1001|       |                    if (fDTD) {
 1002|       |                        if (XMLString::equals(leaf->getRawName(), element->getRawName())) {
 1003|       |                            *newSet |= *fFollowList[leafIndex];
 1004|       |                        }
 1005|       |                    }
 1006|       |                    else {
 1007|       |                        if ((leaf->getURI() == element->getURI()) &&
 1008|       |                            (XMLString::equals(leaf->getLocalPart(), element->getLocalPart()))) {
 1009|       |                            *newSet |= *fFollowList[leafIndex];
 1010|       |                        }
 1011|       |                    }
 1012|       |                }
 1013|       |            } // for leafIndex
 1014|       |#endif
 1015|       |
 1016|       |#ifdef OPTIMIZED_BUT_STILL_LINEAR_SEARCH
 1017|       |            // Optimization(Jan, 2001)
 1018|       |            int leafIndex = fLeafSorter[sorterIndex++];
 1019|       |
 1020|       |            while (leafIndex != -1)
 1021|       |            {
 1022|       |                // If this leaf index (DFA position) is in the current set...
 1023|       |                if (setT->getBit(leafIndex))
 1024|       |                {
 1025|       |                    //
 1026|       |                    //  If this leaf is the current input symbol, then we
 1027|       |                    //  want to add its follow list to the set of states to
 1028|       |                    //  transition to from the current state.
 1029|       |                    //
 1030|       |                    *newSet |= *fFollowList[leafIndex];
 1031|       |                }
 1032|       |                leafIndex = fLeafSorter[sorterIndex++];
 1033|       |            } // while (leafIndex != -1)
 1034|       |#endif
 1035|       |
 1036|   101M|            unsigned int* fLeafIndexes=fLeafSorter[elemIndex];
 1037|   101M|            unsigned int fNumItems=fLeafIndexes[0];
 1038|   101M|            if(fNumItems!=0)
  ------------------
  |  Branch (1038:16): [True: 101M, False: 0]
  ------------------
 1039|   101M|            {
 1040|       |                // The algorithm requires finding the leaf that is present both in the bitfield of the current state, and in the
 1041|       |                // list of places where the currently tested item can appear. When this occurs, the follow list of this parent item
 1042|       |                // is added to the bitfield representing the next state.
 1043|       |                // Both the bitfield and the list of places are sorted, so we can analyze them in two ways; either iterating over the
 1044|       |                // parent items, testing the bitfield for the existence of the parent (N times a constant Tb), or by iterating over the
 1045|       |                // bitfield (restricted to the range of the sorted list of places), using a binary search to locate the leaf in the
 1046|       |                // sorted list of places (M times log(N) testing operations Ts)
 1047|       |                // Assuming that the time to test a bit is roughly the same of the time needed to compute the average of two integers,
 1048|       |                // plus a couple of comparisons and additions, we compare N agains M*log(N) to decide which algorithm should be faster given
 1049|       |                // the two sets
 1050|   101M|                if(fNumItems <= setT->getBitCountInRange(fLeafIndexes[1], fLeafIndexes[fNumItems])*log((float)fNumItems))
  ------------------
  |  Branch (1050:20): [True: 32.1M, False: 69.5M]
  ------------------
 1051|  32.1M|                {
 1052|   525M|                    for(unsigned int i=1; i<=fNumItems; ++i)
  ------------------
  |  Branch (1052:43): [True: 493M, False: 32.1M]
  ------------------
 1053|   493M|                        if(setT->getBit(fLeafIndexes[i]))
  ------------------
  |  Branch (1053:28): [True: 227M, False: 266M]
  ------------------
 1054|   227M|                        {
 1055|       |                            //
 1056|       |                            //  If this leaf is the current input symbol, then we
 1057|       |                            //  want to add its follow list to the set of states to
 1058|       |                            //  transition to from the current state.
 1059|       |                            //
 1060|   227M|                            *newSet |= *fFollowList[ fLeafIndexes[i] ];
 1061|   227M|                        }
 1062|  32.1M|                }
 1063|  69.5M|                else
 1064|  69.5M|                {
 1065|       |                    // Further optimization: given that the bitfield enumerator returns the numbers in order,
 1066|       |                    // every time we raise the lower marker we know it will true also for the next bits, so
 1067|       |                    // the next binary search will not start from 1 but from this index
 1068|  69.5M|                    unsigned int lowIndex = 1;
 1069|       |                    // Start the enumerator from the first index in the sorted list of places,
 1070|       |                    // as nothing before that point will match
 1071|  69.5M|                    CMStateSetEnumerator enumBits(setT, fLeafIndexes[1]);
 1072|   403M|                    while(enumBits.hasMoreElements())
  ------------------
  |  Branch (1072:27): [True: 391M, False: 11.8M]
  ------------------
 1073|   391M|                    {
 1074|   391M|                        unsigned int bitIndex=enumBits.nextElement();
 1075|       |                        // if this leaf is greater than the last index in the sorted list of places,
 1076|       |                        // nothing can be found from now on, so get out of here
 1077|   391M|                        if(bitIndex > fLeafIndexes[fNumItems])
  ------------------
  |  Branch (1077:28): [True: 57.7M, False: 333M]
  ------------------
 1078|  57.7M|                            break;
 1079|       |
 1080|       |                        // Check if this leaf index (DFA position) is in the current set
 1081|       |                        // (using binary search: the indexes are sorted)
 1082|   333M|                        unsigned int first=lowIndex,last=fNumItems,i;
 1083|   818M|                        while(first<=last)
  ------------------
  |  Branch (1083:31): [True: 529M, False: 288M]
  ------------------
 1084|   529M|                        {
 1085|   529M|                            i=(first+last)/2;
 1086|   529M|                            if(fLeafIndexes[i]>bitIndex)
  ------------------
  |  Branch (1086:32): [True: 466M, False: 62.7M]
  ------------------
 1087|   466M|                                last=i-1;
 1088|  62.7M|                            else if(fLeafIndexes[i]<bitIndex)
  ------------------
  |  Branch (1088:37): [True: 18.2M, False: 44.5M]
  ------------------
 1089|  18.2M|                                lowIndex=first=i+1;
 1090|  44.5M|                            else
 1091|  44.5M|                            {
 1092|       |                                //
 1093|       |                                //  If this leaf is the current input symbol, then we
 1094|       |                                //  want to add its follow list to the set of states to
 1095|       |                                //  transition to from the current state.
 1096|       |                                //
 1097|  44.5M|                                *newSet |= *fFollowList[bitIndex];
 1098|  44.5M|                                break;
 1099|  44.5M|                            }
 1100|   529M|                        }
 1101|   333M|                    }
 1102|  69.5M|                }
 1103|   101M|            }
 1104|       |
 1105|       |            //
 1106|       |            //  If this new set is not empty, then see if its in the list
 1107|       |            //  of states to do. If not, then add it.
 1108|       |            //
 1109|   101M|            if (!newSet->isEmpty())
  ------------------
  |  Branch (1109:17): [True: 68.1M, False: 33.5M]
  ------------------
 1110|  68.1M|            {
 1111|       |                //
 1112|       |                //  Search the 'states to do' list to see if this new
 1113|       |                //  state set is already in there.
 1114|       |                //
 1115|       |                /***
 1116|       |                unsigned int stateIndex = 0;
 1117|       |                for (; stateIndex < curState; stateIndex++)
 1118|       |                {
 1119|       |                    if (*statesToDo[stateIndex] == *newSet)
 1120|       |                        break;
 1121|       |                }
 1122|       |                ***/
 1123|       |
 1124|  68.1M|                XMLInteger *stateObj = stateTable->get(newSet);
 1125|  68.1M|                unsigned int stateIndex = (stateObj == 0 ? curState : stateObj->intValue());
  ------------------
  |  Branch (1125:44): [True: 4.31M, False: 63.8M]
  ------------------
 1126|       |
 1127|       |                // If we did not find it, then add it
 1128|  68.1M|                if (stateIndex == curState)
  ------------------
  |  Branch (1128:21): [True: 4.31M, False: 63.8M]
  ------------------
 1129|  4.31M|                {
 1130|       |                    //
 1131|       |                    //  Put this new state into the states to do and init
 1132|       |                    //  a new entry at the same index in the transition
 1133|       |                    //  table.
 1134|       |                    //
 1135|  4.31M|                    statesToDo[curState] = newSet;
 1136|  4.31M|                    fTransTable[curState] = makeDefStateList();
 1137|  4.31M|                    stateTable->put
 1138|  4.31M|                    (
 1139|  4.31M|                        newSet
 1140|  4.31M|                        , new (fMemoryManager) XMLInteger(curState)
 1141|  4.31M|                    );
 1142|       |
 1143|       |                    // We now have a new state to do so bump the count
 1144|  4.31M|                    curState++;
 1145|       |
 1146|       |                    //
 1147|       |                    //  Null out the new set to indicate we adopted it. This
 1148|       |                    //  will cause the creation of a new set on the next time
 1149|       |                    //  around the loop.
 1150|       |                    //
 1151|  4.31M|                    newSet = 0;
 1152|  4.31M|                }
 1153|       |
 1154|       |                //
 1155|       |                //  Now set this state in the transition table's entry for this
 1156|       |                //  element (using its index), with the DFA state we will move
 1157|       |                //  to from the current state when we see this input element.
 1158|       |                //
 1159|  68.1M|                transEntry[elemIndex] = stateIndex;
 1160|       |
 1161|       |                // Expand the arrays if we're full
 1162|  68.1M|                if (curState == curArraySize)
  ------------------
  |  Branch (1162:21): [True: 216, False: 68.1M]
  ------------------
 1163|    216|                {
 1164|       |                    //
 1165|       |                    //  Yikes, we overflowed the initial array size, so we've
 1166|       |                    //  got to expand all of these arrays. So adjust up the
 1167|       |                    //  size by 50% and allocate new arrays.
 1168|       |                    //
 1169|    216|                    const unsigned int newSize = (unsigned int)(curArraySize * 1.5);
 1170|    216|                    CMStateSet** newToDo = (CMStateSet**)
 1171|    216|                        fMemoryManager->allocate
 1172|    216|                        (
 1173|    216|                            newSize * sizeof(CMStateSet*)
 1174|    216|                        ); //new const CMStateSet*[newSize];
 1175|    216|                    bool* newFinalFlags = (bool*) fMemoryManager->allocate
 1176|    216|                    (
 1177|    216|                        newSize * sizeof(bool)
 1178|    216|                    ); //new bool[newSize];
 1179|    216|                    unsigned int** newTransTable = (unsigned int**)
 1180|    216|                        fMemoryManager->allocate
 1181|    216|                        (
 1182|    216|                            newSize * sizeof(unsigned int*)
 1183|    216|                        ); //new unsigned int*[newSize];
 1184|       |
 1185|       |                    // Copy over all of the existing content
 1186|  10.2M|                    for (unsigned int expIndex = 0; expIndex < curArraySize; expIndex++)
  ------------------
  |  Branch (1186:53): [True: 10.2M, False: 216]
  ------------------
 1187|  10.2M|                    {
 1188|  10.2M|                        newToDo[expIndex] = statesToDo[expIndex];
 1189|  10.2M|                        newFinalFlags[expIndex] = fFinalStateFlags[expIndex];
 1190|  10.2M|                        newTransTable[expIndex] = fTransTable[expIndex];
 1191|  10.2M|                    }
 1192|       |
 1193|       |                    // Clean up the old stuff
 1194|    216|                    fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
 1195|    216|                    fMemoryManager->deallocate(fFinalStateFlags); //delete [] fFinalStateFlags;
 1196|    216|                    fMemoryManager->deallocate(fTransTable); //delete [] fTransTable;
 1197|       |
 1198|       |                    // Store the new array size and pointers
 1199|    216|                    curArraySize = newSize;
 1200|    216|                    statesToDo = newToDo;
 1201|    216|                    fFinalStateFlags = newFinalFlags;
 1202|    216|                    fTransTable = newTransTable;
 1203|    216|                } //if (curState == curArraySize)
 1204|  68.1M|            } //if (!newSet->isEmpty())
 1205|   101M|        } // for elemIndex
 1206|  4.31M|    } //while
 1207|       |
 1208|       |    // Store the current state count in the trans table size
 1209|  1.09k|    fTransTableSize = curState;
 1210|       |
 1211|       |    //
 1212|       |    // Fill in the occurence information for each looping state
 1213|       |    // if we're using counters.
 1214|       |    //
 1215|  1.09k|    if (elemOccurenceMap != 0) {
  ------------------
  |  Branch (1215:9): [True: 0, False: 1.09k]
  ------------------
 1216|      0|        fCountingStates = (Occurence**)fMemoryManager->allocate(fTransTableSize*sizeof(Occurence*));
 1217|      0|        memset(fCountingStates, 0, fTransTableSize*sizeof(Occurence*));
 1218|      0|        for (unsigned int i = 0; i < fTransTableSize; ++i) {
  ------------------
  |  Branch (1218:34): [True: 0, False: 0]
  ------------------
 1219|      0|            unsigned int * transitions = fTransTable[i];
 1220|      0|            for (unsigned int j = 0; j < fElemMapSize; ++j) {
  ------------------
  |  Branch (1220:38): [True: 0, False: 0]
  ------------------
 1221|      0|                if (i == transitions[j]) {
  ------------------
  |  Branch (1221:21): [True: 0, False: 0]
  ------------------
 1222|      0|                    Occurence* old=elemOccurenceMap[j];
 1223|      0|                    if(old!=0)
  ------------------
  |  Branch (1223:24): [True: 0, False: 0]
  ------------------
 1224|      0|                        fCountingStates[i] = new (fMemoryManager) Occurence(old->minOccurs, old->maxOccurs, old->elemIndex);
 1225|      0|                    break;
 1226|      0|                }
 1227|      0|            }
 1228|      0|        }
 1229|      0|        for (unsigned int j = 0; j < fLeafCount; ++j) {
  ------------------
  |  Branch (1229:34): [True: 0, False: 0]
  ------------------
 1230|      0|            if(elemOccurenceMap[j]!=0)
  ------------------
  |  Branch (1230:16): [True: 0, False: 0]
  ------------------
 1231|      0|                delete elemOccurenceMap[j];
 1232|      0|        }
 1233|      0|        fMemoryManager->deallocate(elemOccurenceMap);
 1234|      0|    }
 1235|       |
 1236|       |    // If the last temp set was not stored, then clean it up
 1237|  1.09k|    if (newSet)
  ------------------
  |  Branch (1237:9): [True: 1.09k, False: 0]
  ------------------
 1238|  1.09k|        delete newSet;
 1239|       |
 1240|       |    //
 1241|       |    //  Now we can clean up all of the temporary data that was needed during
 1242|       |    //  DFA build.
 1243|       |    //
 1244|       |
 1245|  1.32M|    for (index = 0; index < fLeafCount; index++)
  ------------------
  |  Branch (1245:21): [True: 1.32M, False: 1.09k]
  ------------------
 1246|  1.32M|        delete fFollowList[index];
 1247|  1.09k|    fMemoryManager->deallocate(fFollowList); //delete [] fFollowList;
 1248|       |
 1249|       |    //
 1250|       |    // removeAll() will delete all data, XMLInteger,
 1251|       |    // while the keys are to be deleted by the
 1252|       |    // deletion of statesToDo.
 1253|       |    //
 1254|  1.09k|    delete stateTable;
 1255|       |
 1256|  4.31M|    for (index = 0; index < curState; index++)
  ------------------
  |  Branch (1256:21): [True: 4.31M, False: 1.09k]
  ------------------
 1257|  4.31M|        delete statesToDo[index];
 1258|  1.09k|    fMemoryManager->deallocate(statesToDo); //delete [] statesToDo;
 1259|       |
 1260|  1.32M|    for (index = 0; index < fLeafCount; index++)
  ------------------
  |  Branch (1260:21): [True: 1.32M, False: 1.09k]
  ------------------
 1261|  1.32M|        delete fLeafList[index];
 1262|  1.09k|    fMemoryManager->deallocate(fLeafList); //delete [] fLeafList;
 1263|       |
 1264|       |#ifdef OPTIMIZED_BUT_STILL_LINEAR_SEARCH
 1265|       |    fMemoryManager->deallocate(fLeafSorter); //delete [] fLeafSorter;
 1266|       |#endif
 1267|  32.4k|    for (index=0; index < fElemMapSize; index++)
  ------------------
  |  Branch (1267:19): [True: 31.3k, False: 1.09k]
  ------------------
 1268|  31.3k|        fMemoryManager->deallocate(fLeafSorter[index]);
 1269|  1.09k|    fMemoryManager->deallocate(fLeafSorter);
 1270|  1.09k|}
_ZN11xercesc_3_215DFAContentModel14countLeafNodesEPNS_15ContentSpecNodeE:
 1273|  2.68M|{
 1274|  2.68M|    unsigned int count = 0;
 1275|       |
 1276|       |    // Get the spec type of the passed node
 1277|  2.68M|    const ContentSpecNode::NodeTypes curType = curNode->getType();
 1278|       |
 1279|  2.68M|    if ((curType & 0x0f) == ContentSpecNode::Any
  ------------------
  |  Branch (1279:9): [True: 0, False: 2.68M]
  ------------------
 1280|  2.68M|        || (curType & 0x0f) == ContentSpecNode::Any_Other
  ------------------
  |  Branch (1280:12): [True: 0, False: 2.68M]
  ------------------
 1281|  2.68M|        || (curType & 0x0f) == ContentSpecNode::Any_NS
  ------------------
  |  Branch (1281:12): [True: 0, False: 2.68M]
  ------------------
 1282|  2.68M|        || curType == ContentSpecNode::Leaf
  ------------------
  |  Branch (1282:12): [True: 1.32M, False: 1.35M]
  ------------------
 1283|  2.68M|        || curType == ContentSpecNode::Loop)
  ------------------
  |  Branch (1283:12): [True: 0, False: 1.35M]
  ------------------
 1284|  1.32M|    {
 1285|  1.32M|        count++;
 1286|  1.32M|    }
 1287|  1.35M|    else
 1288|  1.35M|    {
 1289|       |        //
 1290|       |        //  Its not a leaf, so we have to recurse its left and maybe right
 1291|       |        //  nodes. Save both values before we recurse and trash the node.
 1292|       |        //
 1293|  1.35M|        ContentSpecNode* leftNode = curNode->getFirst();
 1294|  1.35M|        ContentSpecNode* rightNode = curNode->getSecond();
 1295|       |
 1296|       |        // Detect if we have a deep tree that can be analyzed using a loop instead of recursion
 1297|  1.35M|        unsigned int nLoopCount=0;
 1298|  1.35M|        ContentSpecNode* cursor=curNode;
 1299|  1.35M|        while(cursor->getType()==ContentSpecNode::Sequence && cursor->getFirst() && cursor->getFirst()->getSecond()==rightNode)
  ------------------
  |  Branch (1299:15): [True: 74.6k, False: 1.28M]
  |  Branch (1299:63): [True: 74.6k, False: 0]
  |  Branch (1299:85): [True: 0, False: 74.6k]
  ------------------
 1300|      0|        {
 1301|      0|            nLoopCount++;
 1302|      0|            cursor=cursor->getFirst();
 1303|      0|        }
 1304|  1.35M|        if(nLoopCount!=0)
  ------------------
  |  Branch (1304:12): [True: 0, False: 1.35M]
  ------------------
 1305|      0|        {
 1306|      0|            count += countLeafNodes(cursor);
 1307|      0|            for(unsigned int i=0;i<nLoopCount;i++)
  ------------------
  |  Branch (1307:34): [True: 0, False: 0]
  ------------------
 1308|      0|                count += countLeafNodes(rightNode);
 1309|      0|            return count;
 1310|      0|        }
 1311|  1.35M|        if(leftNode)
  ------------------
  |  Branch (1311:12): [True: 1.35M, False: 0]
  ------------------
 1312|  1.35M|            count+=countLeafNodes(leftNode);
 1313|  1.35M|        if(rightNode)
  ------------------
  |  Branch (1313:12): [True: 1.32M, False: 38.5k]
  ------------------
 1314|  1.32M|            count+=countLeafNodes(rightNode);
 1315|  1.35M|    }
 1316|  2.68M|    return count;
 1317|  2.68M|}
_ZN11xercesc_3_215DFAContentModel15buildSyntaxTreeEPNS_15ContentSpecNodeERj:
 1321|  2.68M|{
 1322|       |    // Initialize a return node pointer
 1323|  2.68M|    CMNode* retNode = 0;
 1324|       |
 1325|       |    // Get the spec type of the passed node
 1326|  2.68M|    const ContentSpecNode::NodeTypes curType = curNode->getType();
 1327|       |
 1328|  2.68M|    if ((curType & 0x0f) == ContentSpecNode::Any
  ------------------
  |  Branch (1328:9): [True: 0, False: 2.68M]
  ------------------
 1329|  2.68M|        || (curType & 0x0f) == ContentSpecNode::Any_Other
  ------------------
  |  Branch (1329:12): [True: 0, False: 2.68M]
  ------------------
 1330|  2.68M|        || (curType & 0x0f) == ContentSpecNode::Any_NS)
  ------------------
  |  Branch (1330:12): [True: 0, False: 2.68M]
  ------------------
 1331|      0|    {
 1332|      0|        retNode = new (fMemoryManager) CMAny
 1333|      0|        (
 1334|      0|            curType
 1335|      0|            , curNode->getElement()->getURI()
 1336|      0|            , curIndex
 1337|      0|            , fLeafCount
 1338|      0|            , fMemoryManager
 1339|      0|        );
 1340|      0|        fLeafList[curIndex] = new (fMemoryManager) CMLeaf
 1341|      0|        (
 1342|      0|            new (fMemoryManager) QName
 1343|      0|            (
 1344|      0|                XMLUni::fgZeroLenString
 1345|      0|                , XMLUni::fgZeroLenString
 1346|      0|                , curNode->getElement()->getURI()
 1347|      0|                , fMemoryManager
 1348|      0|            )
 1349|      0|            , curIndex
 1350|      0|            , true
 1351|      0|            , fLeafCount
 1352|      0|            , fMemoryManager
 1353|      0|        );
 1354|      0|        fLeafListType[curIndex] = curType;
 1355|      0|        ++curIndex;
 1356|      0|    }
 1357|  2.68M|    else if (curType == ContentSpecNode::Leaf)
  ------------------
  |  Branch (1357:14): [True: 1.32M, False: 1.35M]
  ------------------
 1358|  1.32M|    {
 1359|       |        //
 1360|       |        //  Create a new leaf node, and pass it the current leaf count, which
 1361|       |        //  is its DFA state position. Bump the leaf count after storing it.
 1362|       |        //  This makes the positions zero based since we store first and then
 1363|       |        //  increment.
 1364|       |        //
 1365|  1.32M|        retNode = new (fMemoryManager) CMLeaf
 1366|  1.32M|        (
 1367|  1.32M|            curNode->getElement()
 1368|  1.32M|            , curIndex
 1369|  1.32M|            , fLeafCount
 1370|  1.32M|            , fMemoryManager
 1371|  1.32M|        );
 1372|  1.32M|        fLeafList[curIndex] = new (fMemoryManager) CMLeaf
 1373|  1.32M|        (
 1374|  1.32M|            curNode->getElement()
 1375|  1.32M|            , curIndex
 1376|  1.32M|            , fLeafCount
 1377|  1.32M|            , fMemoryManager
 1378|  1.32M|        );
 1379|  1.32M|        fLeafListType[curIndex] = ContentSpecNode::Leaf;
 1380|  1.32M|        ++curIndex;
 1381|  1.32M|    }
 1382|  1.35M|    else if (curType == ContentSpecNode::Loop)
  ------------------
  |  Branch (1382:14): [True: 0, False: 1.35M]
  ------------------
 1383|      0|    {
 1384|       |        //
 1385|       |        //  Create a new leaf node, and pass it the current leaf count, which
 1386|       |        //  is its DFA state position. Bump the leaf count after storing it.
 1387|       |        //  This makes the positions zero based since we store first and then
 1388|       |        //  increment.
 1389|       |        //
 1390|      0|        retNode = new (fMemoryManager) CMRepeatingLeaf
 1391|      0|        (
 1392|      0|            curNode->getFirst()->getElement()
 1393|      0|            , curNode->getMinOccurs()
 1394|      0|            , curNode->getMaxOccurs()
 1395|      0|            , curIndex
 1396|      0|            , fLeafCount
 1397|      0|            , fMemoryManager
 1398|      0|        );
 1399|      0|        fLeafList[curIndex] = new (fMemoryManager) CMRepeatingLeaf
 1400|      0|        (
 1401|      0|            curNode->getFirst()->getElement()
 1402|      0|            , curNode->getMinOccurs()
 1403|      0|            , curNode->getMaxOccurs()
 1404|      0|            , curIndex
 1405|      0|            , fLeafCount
 1406|      0|            , fMemoryManager
 1407|      0|        );
 1408|      0|        fLeafListType[curIndex] = curNode->getFirst()->getType();
 1409|      0|        ++curIndex;
 1410|      0|    }
 1411|  1.35M|     else
 1412|  1.35M|    {
 1413|       |        //
 1414|       |        //  Its not a leaf, so we have to recurse its left and maybe right
 1415|       |        //  nodes. Save both values before we recurse and trash the node.
 1416|       |        //
 1417|  1.35M|        ContentSpecNode* leftNode = curNode->getFirst();
 1418|  1.35M|        ContentSpecNode* rightNode = curNode->getSecond();
 1419|       |
 1420|       |        // Detect if we have a deep tree that can be analyzed using a loop instead of recursion
 1421|  1.35M|        unsigned int nLoopCount=0;
 1422|  1.35M|        ContentSpecNode* cursor=curNode;
 1423|  1.35M|        while(cursor->getType()==ContentSpecNode::Sequence && cursor->getFirst() && cursor->getFirst()->getSecond()==rightNode)
  ------------------
  |  Branch (1423:15): [True: 74.6k, False: 1.28M]
  |  Branch (1423:63): [True: 74.6k, False: 0]
  |  Branch (1423:85): [True: 0, False: 74.6k]
  ------------------
 1424|      0|        {
 1425|      0|            nLoopCount++;
 1426|      0|            cursor=cursor->getFirst();
 1427|      0|        }
 1428|  1.35M|        if(nLoopCount!=0)
  ------------------
  |  Branch (1428:12): [True: 0, False: 1.35M]
  ------------------
 1429|      0|        {
 1430|      0|            retNode = buildSyntaxTree(cursor, curIndex);
 1431|      0|            for(unsigned int i=0;i<nLoopCount;i++)
  ------------------
  |  Branch (1431:34): [True: 0, False: 0]
  ------------------
 1432|      0|            {
 1433|      0|                CMNode* newRight = buildSyntaxTree(rightNode, curIndex);
 1434|       |                //
 1435|       |                //  Now handle our level. We use our left child's last pos set and our
 1436|       |                //  right child's first pos set, so get them now for convenience.
 1437|       |                //
 1438|      0|                const CMStateSet& last  = retNode->getLastPos();
 1439|      0|                const CMStateSet& first = newRight->getFirstPos();
 1440|       |
 1441|       |                //
 1442|       |                //  Now, for every position which is in our left child's last set
 1443|       |                //  add all of the states in our right child's first set to the
 1444|       |                //  follow set for that position.
 1445|       |                //
 1446|      0|                CMStateSetEnumerator enumLast(&last);
 1447|      0|                while(enumLast.hasMoreElements())
  ------------------
  |  Branch (1447:23): [True: 0, False: 0]
  ------------------
 1448|      0|                {
 1449|      0|                    XMLSize_t index=enumLast.nextElement();
 1450|      0|                    *fFollowList[index] |= first;
 1451|      0|                }
 1452|      0|                retNode = new (fMemoryManager) CMBinaryOp
 1453|      0|                (
 1454|      0|                    ContentSpecNode::Sequence
 1455|      0|                    , retNode
 1456|      0|                    , newRight
 1457|      0|                    , fLeafCount
 1458|      0|                    , fMemoryManager
 1459|      0|                );
 1460|      0|            }
 1461|      0|            return retNode;
 1462|      0|        }
 1463|       |
 1464|  1.35M|        if (((curType & 0x0f) == ContentSpecNode::Choice)
  ------------------
  |  Branch (1464:13): [True: 1.24M, False: 113k]
  ------------------
 1465|  1.35M|        ||   ((curType & 0x0f) == ContentSpecNode::Sequence))
  ------------------
  |  Branch (1465:14): [True: 74.6k, False: 38.5k]
  ------------------
 1466|  1.32M|        {
 1467|       |            //
 1468|       |            //  Recurse on both children, and return a binary op node with the
 1469|       |            //  two created sub nodes as its children. The node type is the
 1470|       |            //  same type as the source.
 1471|       |            //
 1472|  1.32M|            CMNode* newLeft = buildSyntaxTree(leftNode, curIndex);
 1473|  1.32M|            CMNode* newRight = buildSyntaxTree(rightNode, curIndex);
 1474|  1.32M|            if(((curType & 0x0f) == ContentSpecNode::Sequence))
  ------------------
  |  Branch (1474:16): [True: 74.6k, False: 1.24M]
  ------------------
 1475|  74.6k|            {
 1476|       |                //
 1477|       |                //  Now handle our level. We use our left child's last pos set and our
 1478|       |                //  right child's first pos set, so get them now for convenience.
 1479|       |                //
 1480|  74.6k|                const CMStateSet& last  = newLeft->getLastPos();
 1481|  74.6k|                const CMStateSet& first = newRight->getFirstPos();
 1482|       |
 1483|       |                //
 1484|       |                //  Now, for every position which is in our left child's last set
 1485|       |                //  add all of the states in our right child's first set to the
 1486|       |                //  follow set for that position.
 1487|       |                //
 1488|  74.6k|                CMStateSetEnumerator enumLast(&last);
 1489|  1.03M|                while(enumLast.hasMoreElements())
  ------------------
  |  Branch (1489:23): [True: 961k, False: 74.6k]
  ------------------
 1490|   961k|                {
 1491|   961k|                    XMLSize_t index=enumLast.nextElement();
 1492|   961k|                    *fFollowList[index] |= first;
 1493|   961k|                }
 1494|  74.6k|            }
 1495|  1.32M|            retNode = new (fMemoryManager) CMBinaryOp
 1496|  1.32M|            (
 1497|  1.32M|                curType
 1498|  1.32M|                , newLeft
 1499|  1.32M|                , newRight
 1500|  1.32M|                , fLeafCount
 1501|  1.32M|                , fMemoryManager
 1502|  1.32M|            );
 1503|  1.32M|        }
 1504|  38.5k|         else if (curType == ContentSpecNode::ZeroOrMore
  ------------------
  |  Branch (1504:19): [True: 22.8k, False: 15.6k]
  ------------------
 1505|  38.5k|               || curType == ContentSpecNode::ZeroOrOne
  ------------------
  |  Branch (1505:19): [True: 8.83k, False: 6.81k]
  ------------------
 1506|  38.5k|               || curType == ContentSpecNode::OneOrMore)
  ------------------
  |  Branch (1506:19): [True: 6.81k, False: 0]
  ------------------
 1507|  38.5k|        {
 1508|  38.5k|            CMNode* newChild = buildSyntaxTree(leftNode, curIndex);
 1509|  38.5k|            if (curType == ContentSpecNode::ZeroOrMore
  ------------------
  |  Branch (1509:17): [True: 22.8k, False: 15.6k]
  ------------------
 1510|  38.5k|               || curType == ContentSpecNode::OneOrMore)
  ------------------
  |  Branch (1510:19): [True: 6.81k, False: 8.83k]
  ------------------
 1511|  29.6k|            {
 1512|       |                //
 1513|       |                //  Now handle our level. We use our own first and last position
 1514|       |                //  sets, so get them up front.
 1515|       |                //
 1516|  29.6k|                const CMStateSet& first = newChild->getFirstPos();
 1517|  29.6k|                const CMStateSet& last  = newChild->getLastPos();
 1518|       |
 1519|       |                //
 1520|       |                //  For every position which is in our last position set, add all
 1521|       |                //  of our first position states to the follow set for that
 1522|       |                //  position.
 1523|       |                //
 1524|  29.6k|                CMStateSetEnumerator enumLast(&last);
 1525|   563k|                while(enumLast.hasMoreElements())
  ------------------
  |  Branch (1525:23): [True: 534k, False: 29.6k]
  ------------------
 1526|   534k|                {
 1527|   534k|                    XMLSize_t index=enumLast.nextElement();
 1528|   534k|                    *fFollowList[index] |= first;
 1529|   534k|                }
 1530|  29.6k|            }
 1531|       |            // This one is fine as is, just change to our form
 1532|  38.5k|            retNode = new (fMemoryManager) CMUnaryOp
 1533|  38.5k|            (
 1534|  38.5k|                curType
 1535|  38.5k|                , newChild
 1536|  38.5k|                , fLeafCount
 1537|  38.5k|                , fMemoryManager
 1538|  38.5k|            );
 1539|  38.5k|        }
 1540|      0|         else
 1541|      0|        {
 1542|      0|            ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
 1543|      0|        }
 1544|  1.35M|    }
 1545|       |    // fault in the first and last pos, then delete it children
 1546|  2.68M|    retNode->getFirstPos();
 1547|  2.68M|    retNode->getLastPos();
 1548|  2.68M|    retNode->orphanChild();
 1549|  2.68M|    return retNode;
 1550|  2.68M|}
_ZNK11xercesc_3_215DFAContentModel16makeDefStateListEv:
 1558|  4.31M|{
 1559|  4.31M|    unsigned int* retArray = (unsigned int*) fMemoryManager->allocate
 1560|  4.31M|    (
 1561|  4.31M|        fElemMapSize * sizeof(unsigned int)
 1562|  4.31M|    ); //new unsigned int[fElemMapSize];
 1563|   106M|    for (unsigned int index = 0; index < fElemMapSize; index++)
  ------------------
  |  Branch (1563:34): [True: 101M, False: 4.31M]
  ------------------
 1564|   101M|        retArray[index] = XMLContentModel::gInvalidTrans;
 1565|  4.31M|    return retArray;
 1566|  4.31M|}
_ZN11xercesc_3_216CMStateSetHasher10getHashValEPKvm:
   50|  77.5M|  {
   51|  77.5M|    const CMStateSet* const pkey = (const CMStateSet*) key;
   52|  77.5M|    return ((pkey->hashCode()) % mod);
   53|  77.5M|  }
_ZN11xercesc_3_216CMStateSetHasher6equalsEPKvS2_:
   56|  83.0M|  {
   57|  83.0M|    const CMStateSet* const pkey1 = (const CMStateSet*) key1;
   58|  83.0M|    const CMStateSet* const pkey2 = (const CMStateSet*) key2;
   59|  83.0M|    return (*pkey1==*pkey2);
   60|  83.0M|  }

_ZN11xercesc_3_27GrammarC2Ev:
  192|  8.51k|    Grammar(){};

_ZN11xercesc_3_215GrammarResolverC2EPNS_14XMLGrammarPoolEPNS_13MemoryManagerE:
   49|  8.51k|{
   50|  8.51k|    fGrammarBucket = new (manager) RefHashTableOf<Grammar>(29, true,  manager);
   51|       |
   52|       |    /***
   53|       |     * Grammars in this set are not owned
   54|       |     */    
   55|  8.51k|    fGrammarFromPool = new (manager) RefHashTableOf<Grammar>(29, false,  manager);
   56|       |
   57|  8.51k|    if (!gramPool)
  ------------------
  |  Branch (57:9): [True: 8.51k, False: 0]
  ------------------
   58|  8.51k|    {
   59|       |        /***
   60|       |         * We need to instantiate a default grammar pool object so that
   61|       |         * all grammars and grammar components could be created through
   62|       |         * the Factory methods
   63|       |         */
   64|  8.51k|        fGrammarPool = new (manager) XMLGrammarPoolImpl(manager);     
   65|  8.51k|        fGrammarPoolFromExternalApplication=false;
   66|  8.51k|    }
   67|  8.51k|    fStringPool = fGrammarPool->getURIStringPool();
   68|       |
   69|       |    // REVISIT: size
   70|  8.51k|    fGrammarsToAddToXSModel = new (manager) ValueVectorOf<SchemaGrammar*> (29, manager);
   71|  8.51k|}
_ZN11xercesc_3_215GrammarResolverD2Ev:
   74|  8.51k|{  
   75|  8.51k|    delete fGrammarBucket;
   76|  8.51k|    delete fGrammarFromPool;
   77|       |
   78|  8.51k|    if (fDataTypeReg)
  ------------------
  |  Branch (78:9): [True: 0, False: 8.51k]
  ------------------
   79|      0|      delete fDataTypeReg;
   80|       |
   81|       |   /***
   82|       |    *  delete the grammar pool iff it is created by this resolver
   83|       |    */
   84|  8.51k|   if (!fGrammarPoolFromExternalApplication)
  ------------------
  |  Branch (84:8): [True: 8.51k, False: 0]
  ------------------
   85|  8.51k|       delete fGrammarPool;
   86|       |
   87|  8.51k|   if (fXSModel)
  ------------------
  |  Branch (87:8): [True: 0, False: 8.51k]
  ------------------
   88|      0|       delete fXSModel;
   89|       |   // don't delete fGrammarPoolXSModel! we don't own it!
   90|  8.51k|   delete fGrammarsToAddToXSModel;
   91|  8.51k|}
_ZN11xercesc_3_215GrammarResolver10getGrammarEPKDs:
  131|  8.31k|{
  132|  8.31k|    if (!namespaceKey)
  ------------------
  |  Branch (132:9): [True: 0, False: 8.31k]
  ------------------
  133|      0|        return 0;
  134|       |
  135|  8.31k|    Grammar* grammar = fGrammarBucket->get(namespaceKey);
  136|       |
  137|  8.31k|    if (grammar)
  ------------------
  |  Branch (137:9): [True: 8.31k, False: 0]
  ------------------
  138|  8.31k|        return grammar;
  139|       |
  140|      0|    if (fUseCachedGrammar)
  ------------------
  |  Branch (140:9): [True: 0, False: 0]
  ------------------
  141|      0|    {
  142|      0|        grammar = fGrammarFromPool->get(namespaceKey);
  143|      0|        if (grammar)
  ------------------
  |  Branch (143:13): [True: 0, False: 0]
  ------------------
  144|      0|        {
  145|      0|            return grammar;
  146|      0|        }
  147|      0|        else
  148|      0|        {
  149|      0|            XMLSchemaDescription* gramDesc = fGrammarPool->createSchemaDescription(namespaceKey);
  150|      0|            Janitor<XMLGrammarDescription> janName(gramDesc);
  151|      0|            grammar = fGrammarPool->retrieveGrammar(gramDesc);
  152|      0|            if (grammar)
  ------------------
  |  Branch (152:17): [True: 0, False: 0]
  ------------------
  153|      0|            {
  154|      0|                fGrammarFromPool->put((void*) grammar->getGrammarDescription()->getGrammarKey(), grammar);
  155|      0|            }
  156|      0|            return grammar;
  157|      0|        }
  158|      0|    }
  159|       |
  160|      0|    return 0;
  161|      0|}
_ZN11xercesc_3_215GrammarResolver10getGrammarEPNS_21XMLGrammarDescriptionE:
  164|  8.51k|{
  165|  8.51k|    if (!gramDesc)
  ------------------
  |  Branch (165:9): [True: 0, False: 8.51k]
  ------------------
  166|      0|        return 0;
  167|       |
  168|  8.51k|    Grammar* grammar = fGrammarBucket->get(gramDesc->getGrammarKey());
  169|       |
  170|  8.51k|    if (grammar)
  ------------------
  |  Branch (170:9): [True: 0, False: 8.51k]
  ------------------
  171|      0|        return grammar;
  172|       |
  173|  8.51k|    if (fUseCachedGrammar)
  ------------------
  |  Branch (173:9): [True: 0, False: 8.51k]
  ------------------
  174|      0|    {
  175|      0|        grammar = fGrammarFromPool->get(gramDesc->getGrammarKey());
  176|      0|        if (grammar)
  ------------------
  |  Branch (176:13): [True: 0, False: 0]
  ------------------
  177|      0|        {
  178|      0|            return grammar;
  179|      0|        }
  180|      0|        else
  181|      0|        {
  182|      0|            grammar = fGrammarPool->retrieveGrammar(gramDesc);
  183|      0|            if (grammar)
  ------------------
  |  Branch (183:17): [True: 0, False: 0]
  ------------------
  184|      0|            {
  185|      0|                fGrammarFromPool->put((void*) grammar->getGrammarDescription()->getGrammarKey(), grammar);
  186|      0|            }
  187|      0|            return grammar;
  188|      0|        }
  189|      0|    }
  190|       |
  191|  8.51k|    return 0;
  192|  8.51k|}
_ZN11xercesc_3_215GrammarResolver10putGrammarEPNS_7GrammarE:
  235|  8.51k|{
  236|  8.51k|    if (!grammarToAdopt)
  ------------------
  |  Branch (236:9): [True: 0, False: 8.51k]
  ------------------
  237|      0|        return;
  238|       |
  239|       |    /***
  240|       |     * the grammar will be either in the grammarpool, or in the grammarbucket
  241|       |     */
  242|  8.51k|    if (!fCacheGrammar || !fGrammarPool->cacheGrammar(grammarToAdopt))
  ------------------
  |  Branch (242:9): [True: 8.51k, False: 0]
  |  Branch (242:27): [True: 0, False: 0]
  ------------------
  243|  8.51k|    {
  244|       |        // either we aren't caching or the grammar pool doesn't want it
  245|       |        // so we need to look after it
  246|  8.51k|        fGrammarBucket->put( (void*) grammarToAdopt->getGrammarDescription()->getGrammarKey(), grammarToAdopt );
  247|  8.51k|        if (grammarToAdopt->getGrammarType() == Grammar::SchemaGrammarType)
  ------------------
  |  Branch (247:13): [True: 0, False: 8.51k]
  ------------------
  248|      0|        {
  249|      0|            fGrammarsToAddToXSModel->addElement((SchemaGrammar*) grammarToAdopt);
  250|      0|        }
  251|  8.51k|    }
  252|  8.51k|}
_ZN11xercesc_3_215GrammarResolver5resetEv:
  257|  8.51k|void GrammarResolver::reset() {
  258|  8.51k|    fGrammarBucket->removeAll();
  259|  8.51k|    fGrammarsToAddToXSModel->removeAllElements();
  260|  8.51k|    delete fXSModel;
  261|  8.51k|    fXSModel = 0;
  262|  8.51k|}
_ZN11xercesc_3_215GrammarResolver21cacheGrammarFromParseEb:
  321|  8.51k|{
  322|  8.51k|    reset();
  323|  8.51k|    fCacheGrammar = aValue;
  324|  8.51k|}

_ZN11xercesc_3_215GrammarResolver13getStringPoolEv:
  238|  8.51k|inline XMLStringPool* GrammarResolver::getStringPool() {
  239|       |
  240|  8.51k|    return fStringPool;
  241|  8.51k|}
_ZN11xercesc_3_215GrammarResolver23useCachedGrammarInParseEb:
  245|  8.51k|{
  246|  8.51k|    fUseCachedGrammar = aValue;
  247|  8.51k|}
_ZNK11xercesc_3_215GrammarResolver27getGrammarPoolMemoryManagerEv:
  255|  8.51k|{
  256|  8.51k|    return fGrammarPool->getMemoryManager();
  257|  8.51k|}

_ZN11xercesc_3_217MixedContentModelC2EbPNS_15ContentSpecNodeEbPNS_13MemoryManagerE:
   50|    108|{
   51|       |    //
   52|       |    //  Create a vector of unsigned ints that will be filled in with the
   53|       |    //  ids of the child nodes. It will be expanded as needed but we give
   54|       |    //  it an initial capacity of 64 which should be more than enough for
   55|       |    //  99% of the scenarios.
   56|       |    //
   57|    108|    ValueVectorOf<QName*> children(64, fMemoryManager);
   58|    108|    ValueVectorOf<ContentSpecNode::NodeTypes> childTypes(64, fMemoryManager);
   59|       |
   60|       |    //
   61|       |    //  Get the parent element's content spec. This is the head of the tree
   62|       |    //  of nodes that describes the content model. We will iterate this
   63|       |    //  tree.
   64|       |    //
   65|    108|    ContentSpecNode* curNode = parentContentSpec;
   66|    108|    if (!curNode)
  ------------------
  |  Branch (66:9): [True: 0, False: 108]
  ------------------
   67|      0|        ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_NoParentCSN, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   68|       |
   69|       |    // And now call the private recursive method that iterates the tree
   70|    108|    buildChildList(curNode, children, childTypes);
   71|       |
   72|       |    //
   73|       |    //  And now we know how many elements we need in our member list. So
   74|       |    //  fill them in.
   75|       |    //
   76|    108|    fCount = children.size();
   77|    108|    fChildren = (QName**) fMemoryManager->allocate(fCount * sizeof(QName*)); //new QName*[fCount];
   78|    108|    fChildTypes = (ContentSpecNode::NodeTypes*) fMemoryManager->allocate
   79|    108|    (
   80|    108|        fCount * sizeof(ContentSpecNode::NodeTypes)
   81|    108|    ); //new ContentSpecNode::NodeTypes[fCount];
   82|  46.9k|    for (XMLSize_t index = 0; index < fCount; index++) {
  ------------------
  |  Branch (82:31): [True: 46.8k, False: 108]
  ------------------
   83|  46.8k|        fChildren[index] = new (fMemoryManager) QName(*children.elementAt(index));
   84|  46.8k|        fChildTypes[index] = childTypes.elementAt(index);
   85|  46.8k|    }
   86|    108|}
_ZN11xercesc_3_217MixedContentModelD2Ev:
   89|    108|{
   90|  46.9k|    for (XMLSize_t index = 0; index < fCount; index++) {
  ------------------
  |  Branch (90:31): [True: 46.8k, False: 108]
  ------------------
   91|  46.8k|        delete fChildren[index];
   92|  46.8k|    }
   93|    108|    fMemoryManager->deallocate(fChildren); //delete [] fChildren;
   94|    108|    fMemoryManager->deallocate(fChildTypes); //delete [] fChildTypes;
   95|    108|}
_ZNK11xercesc_3_217MixedContentModel15validateContentEPPNS_5QNameEmjPmPNS_13MemoryManagerE:
  147|  1.61k|{
  148|       |    // must match order
  149|  1.61k|    if (fOrdered) {
  ------------------
  |  Branch (149:9): [True: 0, False: 1.61k]
  ------------------
  150|      0|        unsigned int inIndex = 0;
  151|      0|        for (unsigned int outIndex = 0; outIndex < childCount; outIndex++) {
  ------------------
  |  Branch (151:41): [True: 0, False: 0]
  ------------------
  152|       |
  153|       |            // Get the current child out of the source index
  154|      0|            const QName* curChild = children[outIndex];
  155|       |
  156|       |            // If its PCDATA, then we just accept that
  157|      0|            if (curChild->getURI() == XMLElementDecl::fgPCDataElemId)
  ------------------
  |  Branch (157:17): [True: 0, False: 0]
  ------------------
  158|      0|                continue;
  159|       |
  160|      0|            ContentSpecNode::NodeTypes type = fChildTypes[inIndex];
  161|      0|            const QName* inChild = fChildren[inIndex];
  162|       |
  163|      0|            if (type == ContentSpecNode::Leaf) {
  ------------------
  |  Branch (163:17): [True: 0, False: 0]
  ------------------
  164|      0|                if (fDTD) {
  ------------------
  |  Branch (164:21): [True: 0, False: 0]
  ------------------
  165|      0|                    if (!XMLString::equals(inChild->getRawName(), curChild->getRawName())) {
  ------------------
  |  Branch (165:25): [True: 0, False: 0]
  ------------------
  166|      0|                        *indexFailingChild=outIndex;
  167|      0|                        return false;
  168|      0|                    }
  169|      0|                }
  170|      0|                else {
  171|      0|                    if ((inChild->getURI() != curChild->getURI()) ||
  ------------------
  |  Branch (171:25): [True: 0, False: 0]
  ------------------
  172|      0|                        (!XMLString::equals(inChild->getLocalPart(), curChild->getLocalPart()))) {
  ------------------
  |  Branch (172:25): [True: 0, False: 0]
  ------------------
  173|      0|                        *indexFailingChild=outIndex;
  174|      0|                        return false;
  175|      0|                    }
  176|      0|                }
  177|      0|            }
  178|      0|            else if (type == ContentSpecNode::Any) {
  ------------------
  |  Branch (178:22): [True: 0, False: 0]
  ------------------
  179|      0|            }
  180|      0|            else if (type == ContentSpecNode::Any_NS) {
  ------------------
  |  Branch (180:22): [True: 0, False: 0]
  ------------------
  181|      0|                if (inChild->getURI() != curChild->getURI())
  ------------------
  |  Branch (181:21): [True: 0, False: 0]
  ------------------
  182|      0|                {
  183|      0|                    *indexFailingChild=outIndex;
  184|      0|                    return false;
  185|      0|                }
  186|      0|            }
  187|      0|            else if (type == ContentSpecNode::Any_Other)
  ------------------
  |  Branch (187:22): [True: 0, False: 0]
  ------------------
  188|      0|            {
  189|       |                // Here we assume that empty string has id 1.
  190|       |                //
  191|      0|                unsigned int uriId = curChild->getURI();
  192|      0|                if (uriId == 1 || uriId == inChild->getURI())
  ------------------
  |  Branch (192:21): [True: 0, False: 0]
  |  Branch (192:35): [True: 0, False: 0]
  ------------------
  193|      0|                {
  194|      0|                    *indexFailingChild=outIndex;
  195|      0|                    return false;
  196|      0|                }
  197|      0|            }
  198|       |
  199|       |            // advance index
  200|      0|            inIndex++;
  201|      0|        }
  202|      0|    }
  203|       |
  204|       |    // can appear in any order
  205|  1.61k|    else {
  206|  2.41k|        for (unsigned int outIndex = 0; outIndex < childCount; outIndex++) {
  ------------------
  |  Branch (206:41): [True: 1.14k, False: 1.27k]
  ------------------
  207|       |            // Get the current child out of the source index
  208|  1.14k|            const QName* curChild = children[outIndex];
  209|       |
  210|       |            // If its PCDATA, then we just accept that
  211|  1.14k|            if (curChild->getURI() == XMLElementDecl::fgPCDataElemId)
  ------------------
  |  Branch (211:17): [True: 0, False: 1.14k]
  ------------------
  212|      0|                continue;
  213|       |
  214|       |            // And try to find it in our list
  215|  1.14k|            unsigned int inIndex = 0;
  216|  28.9k|            for (; inIndex < fCount; inIndex++)
  ------------------
  |  Branch (216:20): [True: 28.6k, False: 346]
  ------------------
  217|  28.6k|            {
  218|  28.6k|                ContentSpecNode::NodeTypes type = fChildTypes[inIndex];
  219|  28.6k|                const QName* inChild = fChildren[inIndex];
  220|       |
  221|  28.6k|                if (type == ContentSpecNode::Leaf) {
  ------------------
  |  Branch (221:21): [True: 28.6k, False: 0]
  ------------------
  222|  28.6k|                    if (fDTD) {
  ------------------
  |  Branch (222:25): [True: 28.6k, False: 0]
  ------------------
  223|  28.6k|                        if (XMLString::equals(inChild->getRawName(), curChild->getRawName())) {
  ------------------
  |  Branch (223:29): [True: 794, False: 27.8k]
  ------------------
  224|    794|                            break;
  225|    794|                        }
  226|  28.6k|                    }
  227|      0|                    else {
  228|      0|                        if ((inChild->getURI() == curChild->getURI()) &&
  ------------------
  |  Branch (228:29): [True: 0, False: 0]
  ------------------
  229|      0|                            (XMLString::equals(inChild->getLocalPart(), curChild->getLocalPart()))) {
  ------------------
  |  Branch (229:29): [True: 0, False: 0]
  ------------------
  230|      0|                            break;
  231|      0|                        }
  232|      0|                    }
  233|  28.6k|                }
  234|      0|                else if (type == ContentSpecNode::Any) {
  ------------------
  |  Branch (234:26): [True: 0, False: 0]
  ------------------
  235|      0|                    break;
  236|      0|                }
  237|      0|                else if (type == ContentSpecNode::Any_NS) {
  ------------------
  |  Branch (237:26): [True: 0, False: 0]
  ------------------
  238|      0|                    if (inChild->getURI() == curChild->getURI())
  ------------------
  |  Branch (238:25): [True: 0, False: 0]
  ------------------
  239|      0|                        break;
  240|      0|                }
  241|      0|                else if (type == ContentSpecNode::Any_Other)
  ------------------
  |  Branch (241:26): [True: 0, False: 0]
  ------------------
  242|      0|                {
  243|       |                    // Here we assume that empty string has id 1.
  244|       |                    //
  245|      0|                    unsigned int uriId = curChild->getURI();
  246|      0|                    if (uriId != 1 && uriId != inChild->getURI())
  ------------------
  |  Branch (246:25): [True: 0, False: 0]
  |  Branch (246:39): [True: 0, False: 0]
  ------------------
  247|      0|                        break;
  248|      0|                }
  249|       |
  250|       |                // REVISIT: What about checking for multiple ANY matches?
  251|       |                //          The content model ambiguity *could* be checked
  252|       |                //          by the caller before constructing the mixed
  253|       |                //          content model.
  254|  28.6k|            }
  255|       |            // We did not find this one, so the validation failed
  256|  1.14k|            if (inIndex == fCount)
  ------------------
  |  Branch (256:17): [True: 346, False: 794]
  ------------------
  257|    346|            {
  258|    346|                *indexFailingChild=outIndex;
  259|    346|                return false;
  260|    346|            }
  261|  1.14k|        }
  262|  1.61k|    }
  263|       |
  264|       |    // Everything seems to be in order, so return success
  265|  1.27k|    return true;
  266|  1.61k|}
_ZN11xercesc_3_217MixedContentModel14buildChildListEPNS_15ContentSpecNodeERNS_13ValueVectorOfIPNS_5QNameEEERNS3_INS1_9NodeTypesEEE:
  390|  93.7k|{
  391|       |    // Get the type of spec node our current node is
  392|  93.7k|    const ContentSpecNode::NodeTypes curType = curNode->getType();
  393|       |
  394|       |    // If its a leaf, then store its id in the target list
  395|  93.7k|    if ((curType == ContentSpecNode::Leaf)      ||
  ------------------
  |  Branch (395:9): [True: 46.8k, False: 46.8k]
  ------------------
  396|  93.7k|        (curType == ContentSpecNode::Any)       ||
  ------------------
  |  Branch (396:9): [True: 0, False: 46.8k]
  ------------------
  397|  93.7k|        (curType == ContentSpecNode::Any_Other) ||
  ------------------
  |  Branch (397:9): [True: 0, False: 46.8k]
  ------------------
  398|  93.7k|        (curType == ContentSpecNode::Any_NS)   )
  ------------------
  |  Branch (398:9): [True: 0, False: 46.8k]
  ------------------
  399|  46.8k|    {
  400|  46.8k|        toFill.addElement(curNode->getElement());
  401|  46.8k|        toType.addElement(curType);
  402|  46.8k|        return;
  403|  46.8k|    }
  404|       |
  405|       |    // Get both the child node pointers
  406|  46.8k|    ContentSpecNode* leftNode = curNode->getFirst();
  407|  46.8k|    ContentSpecNode* rightNode = curNode->getSecond();
  408|       |
  409|       |    // And recurse according to the type of node
  410|  46.8k|    if (((curType & 0x0f) == ContentSpecNode::Choice)
  ------------------
  |  Branch (410:9): [True: 46.7k, False: 83]
  ------------------
  411|  46.8k|    ||  ((curType & 0x0f) == ContentSpecNode::Sequence))
  ------------------
  |  Branch (411:9): [True: 0, False: 83]
  ------------------
  412|  46.7k|    {
  413|       |        // Recurse on the left and right nodes
  414|  46.7k|        buildChildList(leftNode, toFill, toType);
  415|       |
  416|       |        // The last node of a choice or sequence has a null right
  417|  46.7k|        if (rightNode)
  ------------------
  |  Branch (417:13): [True: 46.7k, False: 0]
  ------------------
  418|  46.7k|            buildChildList(rightNode, toFill, toType);
  419|  46.7k|    }
  420|     83|    else if ((curType == ContentSpecNode::OneOrMore)
  ------------------
  |  Branch (420:14): [True: 0, False: 83]
  ------------------
  421|     83|         ||  (curType == ContentSpecNode::ZeroOrOne)
  ------------------
  |  Branch (421:14): [True: 0, False: 83]
  ------------------
  422|     83|         ||  (curType == ContentSpecNode::ZeroOrMore))
  ------------------
  |  Branch (422:14): [True: 83, False: 0]
  ------------------
  423|     83|    {
  424|       |        // Just do the left node on this one
  425|     83|        buildChildList(leftNode, toFill, toType);
  426|     83|    }
  427|  46.8k|}

_ZNK11xercesc_3_218SimpleContentModel15validateContentEPPNS_5QNameEmjPmPNS_13MemoryManagerE:
   48|  16.3k|{
   49|       |    //
   50|       |    //  According to the type of operation, we do the correct type of
   51|       |    //  content check.
   52|       |    //
   53|  16.3k|    XMLSize_t index;
   54|  16.3k|    switch(fOp & 0x0f)
   55|  16.3k|    {
   56|  2.63k|        case ContentSpecNode::Leaf :
  ------------------
  |  Branch (56:9): [True: 2.63k, False: 13.6k]
  ------------------
   57|       |            //
   58|       |            //  There can only be one child and it has to be of the
   59|       |            //  element type we stored.
   60|       |            //
   61|  2.63k|            if (!childCount)
  ------------------
  |  Branch (61:17): [True: 1.45k, False: 1.17k]
  ------------------
   62|  1.45k|            {
   63|  1.45k|                *indexFailingChild=0;
   64|  1.45k|                return false;
   65|  1.45k|            }
   66|       |
   67|       |            // If the 0th child is not the right kind, report an error at 0
   68|  1.17k|            if (fDTD) {
  ------------------
  |  Branch (68:17): [True: 1.17k, False: 0]
  ------------------
   69|  1.17k|                if (!XMLString::equals(children[0]->getRawName(), fFirstChild->getRawName())) {
  ------------------
  |  Branch (69:21): [True: 415, False: 760]
  ------------------
   70|    415|                    *indexFailingChild=0;
   71|    415|                    return false;
   72|    415|                }
   73|  1.17k|            }
   74|      0|            else {
   75|      0|                if ((children[0]->getURI() != fFirstChild->getURI()) ||
  ------------------
  |  Branch (75:21): [True: 0, False: 0]
  ------------------
   76|      0|                    !XMLString::equals(children[0]->getLocalPart(), fFirstChild->getLocalPart())) {
  ------------------
  |  Branch (76:21): [True: 0, False: 0]
  ------------------
   77|      0|                    *indexFailingChild=0;
   78|      0|                    return false;
   79|      0|                }
   80|      0|            }
   81|       |
   82|    760|            if (childCount > 1)
  ------------------
  |  Branch (82:17): [True: 312, False: 448]
  ------------------
   83|    312|            {
   84|    312|                *indexFailingChild=1;
   85|    312|                return false;
   86|    312|            }
   87|    448|            break;
   88|       |
   89|  1.91k|        case ContentSpecNode::ZeroOrOne :
  ------------------
  |  Branch (89:9): [True: 1.91k, False: 14.3k]
  ------------------
   90|       |            //
   91|       |            //  If the child count is greater than one, then obviously
   92|       |            //  bad. Otherwise, if its one, then the one child must be
   93|       |            //  of the type we stored.
   94|       |            //
   95|  1.91k|            if (childCount == 1) {
  ------------------
  |  Branch (95:17): [True: 673, False: 1.24k]
  ------------------
   96|    673|                if (fDTD) {
  ------------------
  |  Branch (96:21): [True: 673, False: 0]
  ------------------
   97|    673|                    if (!XMLString::equals(children[0]->getRawName(), fFirstChild->getRawName())) {
  ------------------
  |  Branch (97:25): [True: 434, False: 239]
  ------------------
   98|    434|                        *indexFailingChild=0;
   99|    434|                        return false;
  100|    434|                    }
  101|    673|                }
  102|      0|                else {
  103|      0|                    if ((children[0]->getURI() != fFirstChild->getURI()) ||
  ------------------
  |  Branch (103:25): [True: 0, False: 0]
  ------------------
  104|      0|                        (!XMLString::equals(children[0]->getLocalPart(), fFirstChild->getLocalPart()))) {
  ------------------
  |  Branch (104:25): [True: 0, False: 0]
  ------------------
  105|      0|                        *indexFailingChild=0;
  106|      0|                        return false;
  107|      0|                    }
  108|      0|                }
  109|    673|            }
  110|       |
  111|  1.48k|            if (childCount > 1)
  ------------------
  |  Branch (111:17): [True: 322, False: 1.16k]
  ------------------
  112|    322|            {
  113|    322|                *indexFailingChild=1;
  114|    322|                return false;
  115|    322|            }
  116|  1.16k|            break;
  117|       |
  118|  1.78k|        case ContentSpecNode::ZeroOrMore :
  ------------------
  |  Branch (118:9): [True: 1.78k, False: 14.5k]
  ------------------
  119|       |            //
  120|       |            //  If the child count is zero, that's fine. If its more than
  121|       |            //  zero, then make sure that all children are of the element
  122|       |            //  type that we stored.
  123|       |            //
  124|  1.78k|            if (childCount > 0)
  ------------------
  |  Branch (124:17): [True: 758, False: 1.02k]
  ------------------
  125|    758|            {
  126|    758|                if (fDTD) {
  ------------------
  |  Branch (126:21): [True: 758, False: 0]
  ------------------
  127|  1.84k|                    for (index = 0; index < childCount; index++) {
  ------------------
  |  Branch (127:37): [True: 1.36k, False: 486]
  ------------------
  128|  1.36k|                        if (!XMLString::equals(children[index]->getRawName(), fFirstChild->getRawName())) {
  ------------------
  |  Branch (128:29): [True: 272, False: 1.09k]
  ------------------
  129|    272|                            *indexFailingChild=index;
  130|    272|                            return false;
  131|    272|                        }
  132|  1.36k|                    }
  133|    758|                }
  134|      0|                else {
  135|      0|                    for (index = 0; index < childCount; index++) {
  ------------------
  |  Branch (135:37): [True: 0, False: 0]
  ------------------
  136|      0|                        if ((children[index]->getURI() != fFirstChild->getURI()) ||
  ------------------
  |  Branch (136:29): [True: 0, False: 0]
  ------------------
  137|      0|                            !XMLString::equals(children[index]->getLocalPart(), fFirstChild->getLocalPart())) {
  ------------------
  |  Branch (137:29): [True: 0, False: 0]
  ------------------
  138|      0|                            *indexFailingChild=index;
  139|      0|                            return false;
  140|      0|                        }
  141|      0|                    }
  142|      0|                }
  143|    758|            }
  144|  1.51k|            break;
  145|       |
  146|  1.51k|        case ContentSpecNode::OneOrMore :
  ------------------
  |  Branch (146:9): [True: 1.40k, False: 14.9k]
  ------------------
  147|       |            //
  148|       |            //  If the child count is zero, that's an error. If its more
  149|       |            //  than zero, then make sure that all children are of the
  150|       |            //  element type that we stored.
  151|       |            //
  152|  1.40k|            if (childCount == 0)
  ------------------
  |  Branch (152:17): [True: 726, False: 676]
  ------------------
  153|    726|            {
  154|    726|                *indexFailingChild=0;
  155|    726|                return false;
  156|    726|            }
  157|       |
  158|    676|            if (fDTD) {
  ------------------
  |  Branch (158:17): [True: 676, False: 0]
  ------------------
  159|  1.49k|                for (index = 0; index < childCount; index++) {
  ------------------
  |  Branch (159:33): [True: 1.13k, False: 365]
  ------------------
  160|  1.13k|                    if (!XMLString::equals(children[index]->getRawName(), fFirstChild->getRawName())) {
  ------------------
  |  Branch (160:25): [True: 311, False: 821]
  ------------------
  161|    311|                        *indexFailingChild=index;
  162|    311|                        return false;
  163|    311|                    }
  164|  1.13k|                }
  165|    676|            }
  166|      0|            else {
  167|      0|                for (index = 0; index < childCount; index++) {
  ------------------
  |  Branch (167:33): [True: 0, False: 0]
  ------------------
  168|      0|                    if ((children[index]->getURI() != fFirstChild->getURI()) ||
  ------------------
  |  Branch (168:25): [True: 0, False: 0]
  ------------------
  169|      0|                        !XMLString::equals(children[index]->getLocalPart(), fFirstChild->getLocalPart())) {
  ------------------
  |  Branch (169:25): [True: 0, False: 0]
  ------------------
  170|      0|                        *indexFailingChild=index;
  171|      0|                        return false;
  172|      0|                    }
  173|      0|                }
  174|      0|            }
  175|    365|            break;
  176|       |
  177|  3.82k|        case ContentSpecNode::Choice :
  ------------------
  |  Branch (177:9): [True: 3.82k, False: 12.4k]
  ------------------
  178|       |            //
  179|       |            //  There can only be one child, and it must be one of the
  180|       |            //  two types we stored.
  181|       |            //
  182|  3.82k|            if (!childCount)
  ------------------
  |  Branch (182:17): [True: 1.73k, False: 2.08k]
  ------------------
  183|  1.73k|            {
  184|  1.73k|                *indexFailingChild=0;
  185|  1.73k|                return false;
  186|  1.73k|            }
  187|       |
  188|  2.08k|            if (fDTD) {
  ------------------
  |  Branch (188:17): [True: 2.08k, False: 0]
  ------------------
  189|  2.08k|                if (!XMLString::equals(children[0]->getRawName(), fFirstChild->getRawName()) &&
  ------------------
  |  Branch (189:21): [True: 1.86k, False: 227]
  ------------------
  190|  2.08k|                    !XMLString::equals(children[0]->getRawName(), fSecondChild->getRawName())) {
  ------------------
  |  Branch (190:21): [True: 903, False: 959]
  ------------------
  191|    903|                    *indexFailingChild=0;
  192|    903|                    return false;
  193|    903|                }
  194|  2.08k|            }
  195|      0|            else {
  196|      0|                if (((children[0]->getURI() != fFirstChild->getURI()) ||
  ------------------
  |  Branch (196:22): [True: 0, False: 0]
  ------------------
  197|      0|                     !XMLString::equals(children[0]->getLocalPart(), fFirstChild->getLocalPart())) &&
  ------------------
  |  Branch (197:22): [True: 0, False: 0]
  ------------------
  198|      0|                    ((children[0]->getURI() != fSecondChild->getURI()) ||
  ------------------
  |  Branch (198:22): [True: 0, False: 0]
  ------------------
  199|      0|                     !XMLString::equals(children[0]->getLocalPart(), fSecondChild->getLocalPart()))) {
  ------------------
  |  Branch (199:22): [True: 0, False: 0]
  ------------------
  200|      0|                     *indexFailingChild=0;
  201|      0|                     return false;
  202|      0|                }
  203|      0|            }
  204|       |
  205|  1.18k|            if (childCount > 1)
  ------------------
  |  Branch (205:17): [True: 344, False: 842]
  ------------------
  206|    344|            {
  207|    344|                *indexFailingChild=1;
  208|    344|                return false;
  209|    344|            }
  210|    842|            break;
  211|       |
  212|  4.75k|        case ContentSpecNode::Sequence :
  ------------------
  |  Branch (212:9): [True: 4.75k, False: 11.5k]
  ------------------
  213|       |            //
  214|       |            //  There must be two children and they must be the two values
  215|       |            //  we stored, in the stored order. So first check the obvious
  216|       |            //  problem of an empty content, which would never be valid
  217|       |            //  in this content mode.
  218|       |            //
  219|  4.75k|            if (!childCount)
  ------------------
  |  Branch (219:17): [True: 2.50k, False: 2.25k]
  ------------------
  220|  2.50k|            {
  221|  2.50k|                *indexFailingChild=0;
  222|  2.50k|                return false;
  223|  2.50k|            }
  224|       |
  225|       |            // test first child
  226|  2.25k|            if (fDTD) {
  ------------------
  |  Branch (226:17): [True: 2.25k, False: 0]
  ------------------
  227|  2.25k|                if (!XMLString::equals(children[0]->getRawName(), fFirstChild->getRawName())) {
  ------------------
  |  Branch (227:21): [True: 433, False: 1.81k]
  ------------------
  228|    433|                    *indexFailingChild=0;
  229|    433|                    return false;
  230|    433|                }
  231|  2.25k|            }
  232|      0|            else {
  233|      0|                if ((children[0]->getURI() != fFirstChild->getURI()) ||
  ------------------
  |  Branch (233:21): [True: 0, False: 0]
  ------------------
  234|      0|                    !XMLString::equals(children[0]->getLocalPart(), fFirstChild->getLocalPart())) {
  ------------------
  |  Branch (234:21): [True: 0, False: 0]
  ------------------
  235|      0|                    *indexFailingChild=0;
  236|      0|                    return false;
  237|      0|                }
  238|      0|            }
  239|       |            // test second child, if present
  240|  1.81k|            if( childCount == 1)
  ------------------
  |  Branch (240:17): [True: 929, False: 888]
  ------------------
  241|    929|            {
  242|       |                // missing second child
  243|    929|                *indexFailingChild=1;
  244|    929|                return false;
  245|    929|            }
  246|    888|            else
  247|    888|            {
  248|    888|                if (fDTD) {
  ------------------
  |  Branch (248:21): [True: 888, False: 0]
  ------------------
  249|    888|                    if (!XMLString::equals(children[1]->getRawName(), fSecondChild->getRawName())) {
  ------------------
  |  Branch (249:25): [True: 288, False: 600]
  ------------------
  250|    288|                        *indexFailingChild=1;
  251|    288|                        return false;
  252|    288|                    }
  253|    888|                }
  254|      0|                else {
  255|      0|                    if ((children[1]->getURI() != fSecondChild->getURI()) ||
  ------------------
  |  Branch (255:25): [True: 0, False: 0]
  ------------------
  256|      0|                        !XMLString::equals(children[1]->getLocalPart(), fSecondChild->getLocalPart())) {
  ------------------
  |  Branch (256:25): [True: 0, False: 0]
  ------------------
  257|      0|                        *indexFailingChild=1;
  258|      0|                        return false;
  259|      0|                    }
  260|      0|                }
  261|       |
  262|    600|                if (childCount > 2) {
  ------------------
  |  Branch (262:21): [True: 275, False: 325]
  ------------------
  263|    275|                    *indexFailingChild=2;
  264|    275|                    return false;
  265|    275|                }
  266|    600|            }
  267|    325|            break;
  268|       |
  269|    325|        default :
  ------------------
  |  Branch (269:9): [True: 0, False: 16.3k]
  ------------------
  270|      0|            ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::CM_UnknownCMSpecType, fMemoryManager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  271|      0|            break;
  272|  16.3k|    }
  273|  4.65k|    return true;
  274|  16.3k|}

_ZN11xercesc_3_218SimpleContentModelD2Ev:
  182|    388|{
  183|    388|    delete fFirstChild;
  184|    388|    delete fSecondChild;
  185|    388|}
_ZN11xercesc_3_218SimpleContentModelC2EbPNS_5QNameES2_NS_15ContentSpecNode9NodeTypesEPNS_13MemoryManagerE:
  169|    388|{
  170|    388|    if (firstChild)
  ------------------
  |  Branch (170:9): [True: 388, False: 0]
  ------------------
  171|    388|        fFirstChild = new (manager) QName(*firstChild);
  172|      0|    else
  173|      0|        fFirstChild = new (manager) QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId, manager);
  174|       |
  175|    388|    if (secondChild)
  ------------------
  |  Branch (175:9): [True: 149, False: 239]
  ------------------
  176|    149|        fSecondChild = new (manager) QName(*secondChild);
  177|    239|    else
  178|    239|        fSecondChild = new (manager) QName(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, XMLElementDecl::fgInvalidElemId, manager);
  179|    388|}

_ZN11xercesc_3_229AbstractNumericFacetValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEiNS1_13ValidatorTypeEPNS_13MemoryManagerE:
  109|     25|{
  110|       |    //do not invoke init() here !!!
  111|     25|}
_ZN11xercesc_3_229AbstractNumericFacetValidator4initEPNS_16RefArrayVectorOfIDsEEPNS_13MemoryManagerE:
  118|     13|{
  119|       |
  120|     13|    fStrEnumeration = enums; // save the literal value
  121|       |	                         // which is needed for getEnumString()
  122|       |
  123|     13|    if (enums)
  ------------------
  |  Branch (123:9): [True: 0, False: 13]
  ------------------
  124|      0|    {
  125|      0|        setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
  126|      0|    }
  127|       |
  128|     13|    assignFacet(manager);
  129|     13|    inspectFacet(manager);
  130|     13|    inspectFacetBase(manager);
  131|     13|    inheritFacet();
  132|     13|}
_ZN11xercesc_3_229AbstractNumericFacetValidator11assignFacetEPNS_13MemoryManagerE:
  140|     13|{
  141|       |
  142|     13|    RefHashTableOf<KVStringPair>* facets = getFacets();
  143|       |
  144|     13|    if (!facets)     // no facets defined
  ------------------
  |  Branch (144:9): [True: 0, False: 13]
  ------------------
  145|      0|        return;
  146|       |
  147|     13|    XMLCh* key;
  148|       |
  149|     13|    RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
  150|       |
  151|     31|    while (e.hasMoreElements())
  ------------------
  |  Branch (151:12): [True: 18, False: 13]
  ------------------
  152|     18|    {
  153|     18|        KVStringPair pair = e.nextElement();
  154|     18|        key = pair.getKey();
  155|     18|        XMLCh* value = pair.getValue();
  156|       |
  157|     18|        if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
  ------------------
  |  Branch (157:13): [True: 1, False: 17]
  ------------------
  158|      1|        {
  159|      1|            setPattern(value);
  160|      1|            if (getPattern())
  ------------------
  |  Branch (160:17): [True: 1, False: 0]
  ------------------
  161|      1|                setFacetsDefined(DatatypeValidator::FACET_PATTERN);
  162|       |            // do not construct regex until needed
  163|      1|        }
  164|     17|        else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXINCLUSIVE))
  ------------------
  |  Branch (164:18): [True: 10, False: 7]
  ------------------
  165|     10|        {
  166|     10|            try
  167|     10|            {
  168|     10|                setMaxInclusive(value);
  169|     10|            }
  170|     10|            catch (NumberFormatException&)
  171|     10|            {
  172|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxIncl, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  173|      0|            }
  174|     10|            setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
  175|     10|        }
  176|      7|        else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXEXCLUSIVE))
  ------------------
  |  Branch (176:18): [True: 0, False: 7]
  ------------------
  177|      0|        {
  178|      0|            try
  179|      0|            {
  180|      0|                setMaxExclusive(value);
  181|      0|            }
  182|      0|            catch (NumberFormatException&)
  183|      0|            {
  184|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MaxExcl, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  185|      0|            }
  186|      0|            setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
  187|      0|        }
  188|      7|        else if (XMLString::equals(key, SchemaSymbols::fgELT_MININCLUSIVE))
  ------------------
  |  Branch (188:18): [True: 6, False: 1]
  ------------------
  189|      6|        {
  190|      6|            try
  191|      6|            {
  192|      6|                setMinInclusive(value);
  193|      6|            }
  194|      6|            catch (NumberFormatException&)
  195|      6|            {
  196|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinIncl, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  197|      0|            }
  198|      6|            setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
  199|      6|        }
  200|      1|        else if (XMLString::equals(key, SchemaSymbols::fgELT_MINEXCLUSIVE))
  ------------------
  |  Branch (200:18): [True: 0, False: 1]
  ------------------
  201|      0|        {
  202|      0|            try
  203|      0|            {
  204|      0|                setMinExclusive(value);
  205|      0|            }
  206|      0|            catch (NumberFormatException&)
  207|      0|            {
  208|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_MinExcl, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  209|      0|            }
  210|      0|            setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
  211|      0|        }
  212|      1|        else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
  ------------------
  |  Branch (212:18): [True: 0, False: 1]
  ------------------
  213|      0|        {
  214|      0|            unsigned int val;
  215|      0|            bool         retStatus;
  216|      0|            try
  217|      0|            {
  218|      0|                retStatus = XMLString::textToBin(value, val, fMemoryManager);
  219|      0|            }
  220|      0|            catch (RuntimeException&)
  221|      0|            {
  222|      0|                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  223|      0|            }
  224|       |
  225|      0|            if (!retStatus)
  ------------------
  |  Branch (225:17): [True: 0, False: 0]
  ------------------
  226|      0|            {
  227|      0|                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  228|      0|            }
  229|       |
  230|      0|            setFixed(val);
  231|       |            //no setFacetsDefined here
  232|       |
  233|      0|        }
  234|      1|        else
  235|      1|        {
  236|      1|            assignAdditionalFacet(key, value, manager);
  237|      1|        }
  238|       |
  239|     18|    }//while
  240|       |
  241|     13|}// end of assigneFacet()
_ZN11xercesc_3_229AbstractNumericFacetValidator12inspectFacetEPNS_13MemoryManagerE:
  249|     13|{
  250|       |
  251|     13|    int thisFacetsDefined = getFacetsDefined();
  252|     13|    XMLNumber *thisMaxInclusive = getMaxInclusive();
  253|     13|    XMLNumber *thisMaxExclusive = getMaxExclusive();
  254|     13|    XMLNumber *thisMinInclusive = getMinInclusive();
  255|     13|    XMLNumber *thisMinExclusive = getMinExclusive();
  256|       |
  257|     13|    if (!thisFacetsDefined)
  ------------------
  |  Branch (257:9): [True: 0, False: 13]
  ------------------
  258|      0|        return;
  259|       |
  260|       |    // non co-existence checking
  261|       |    // check 4.3.8.c1 error: maxInclusive + maxExclusive
  262|     13|    if (((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (262:9): [True: 0, False: 13]
  ------------------
  263|     13|        ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) )
  ------------------
  |  Branch (263:9): [True: 0, False: 0]
  ------------------
  264|      0|        ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_max_Incl_Excl, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  265|       |
  266|       |    // non co-existence checking
  267|       |    // check 4.3.9.c1 error: minInclusive + minExclusive
  268|     13|    if (((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (268:9): [True: 0, False: 13]
  ------------------
  269|     13|        ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  ------------------
  |  Branch (269:9): [True: 0, False: 0]
  ------------------
  270|      0|        ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_min_Incl_Excl, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  271|       |
  272|       |    //
  273|       |    // minExclusive < minInclusive <= maxInclusive < maxExclusive
  274|       |    //
  275|       |    // check 4.3.7.c1 must: minInclusive <= maxInclusive
  276|     13|    if (((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  ------------------
  |  Branch (276:9): [True: 10, False: 3]
  ------------------
  277|     13|        ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  ------------------
  |  Branch (277:9): [True: 4, False: 6]
  ------------------
  278|      4|    {
  279|      4|        int result = compareValues(thisMinInclusive, thisMaxInclusive);
  280|      4|        if ( result == 1 || result == INDETERMINATE )
  ------------------
  |  Branch (280:14): [True: 0, False: 4]
  |  Branch (280:29): [True: 0, False: 4]
  ------------------
  281|      0|        {
  282|      0|            REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  283|      0|                             , thisMaxInclusive
  284|      0|                             , XMLExcepts::FACET_maxIncl_minIncl
  285|      0|                             , manager)
  286|      0|        }
  287|      4|    }
  288|       |
  289|       |    // check 4.3.8.c2 must: minExclusive <= maxExclusive
  290|     13|    if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (290:10): [True: 0, False: 13]
  ------------------
  291|     13|        ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
  ------------------
  |  Branch (291:9): [True: 0, False: 0]
  ------------------
  292|      0|    {
  293|      0|        int result = compareValues(getMinExclusive(), getMaxExclusive());
  294|      0|        if ( result == 1 || result == INDETERMINATE )
  ------------------
  |  Branch (294:14): [True: 0, False: 0]
  |  Branch (294:29): [True: 0, False: 0]
  ------------------
  295|      0|        {
  296|      0|            REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  297|      0|                             , thisMaxExclusive
  298|      0|                             , XMLExcepts::FACET_maxExcl_minExcl
  299|      0|                             , manager)
  300|      0|        }
  301|      0|    }
  302|       |
  303|       |    // check 4.3.9.c2 must: minExclusive < maxInclusive
  304|     13|    if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  ------------------
  |  Branch (304:10): [True: 10, False: 3]
  ------------------
  305|     13|        ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) )
  ------------------
  |  Branch (305:9): [True: 0, False: 10]
  ------------------
  306|      0|    {
  307|      0|        int result = compareValues(getMinExclusive(), getMaxInclusive());
  308|      0|        if ( result != -1 )
  ------------------
  |  Branch (308:14): [True: 0, False: 0]
  ------------------
  309|      0|        {
  310|      0|            REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  311|      0|                             , thisMaxInclusive
  312|      0|                             , XMLExcepts::FACET_maxIncl_minExcl
  313|      0|                             , manager)
  314|      0|        }
  315|      0|    }
  316|       |
  317|       |    // check 4.3.10.c1 must: minInclusive < maxExclusive
  318|     13|    if ( ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (318:10): [True: 0, False: 13]
  ------------------
  319|     13|        ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) )
  ------------------
  |  Branch (319:9): [True: 0, False: 0]
  ------------------
  320|      0|    {
  321|      0|        int result = compareValues(getMinInclusive(), getMaxExclusive());
  322|      0|        if ( result != -1)
  ------------------
  |  Branch (322:14): [True: 0, False: 0]
  ------------------
  323|      0|        {
  324|      0|            REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  325|      0|                             , thisMaxExclusive
  326|      0|                             , XMLExcepts::FACET_maxExcl_minIncl
  327|      0|                             , manager)
  328|      0|        }
  329|      0|    }
  330|       |
  331|     13|    checkAdditionalFacetConstraints(manager);
  332|       |
  333|     13|}// end of inspectFacet()
_ZN11xercesc_3_229AbstractNumericFacetValidator16inspectFacetBaseEPNS_13MemoryManagerE:
  342|     13|{
  343|       |
  344|     13|    AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
  345|     13|    int thisFacetsDefined = getFacetsDefined();
  346|       |
  347|     13|    if ( (!thisFacetsDefined && !fEnumeration) ||
  ------------------
  |  Branch (347:11): [True: 0, False: 13]
  |  Branch (347:33): [True: 0, False: 0]
  ------------------
  348|     13|         !numBase           )
  ------------------
  |  Branch (348:10): [True: 0, False: 13]
  ------------------
  349|      0|        return;
  350|       |
  351|     13|    int baseFacetsDefined = numBase->getFacetsDefined();
  352|       |
  353|     13|    XMLNumber *thisMaxInclusive = getMaxInclusive();
  354|     13|    XMLNumber *thisMaxExclusive = getMaxExclusive();
  355|     13|    XMLNumber *thisMinInclusive = getMinInclusive();
  356|     13|    XMLNumber *thisMinExclusive = getMinExclusive();
  357|       |
  358|     13|    XMLNumber *baseMaxInclusive = numBase->getMaxInclusive();
  359|     13|    XMLNumber *baseMaxExclusive = numBase->getMaxExclusive();
  360|     13|    XMLNumber *baseMinInclusive = numBase->getMinInclusive();
  361|     13|    XMLNumber *baseMinExclusive = numBase->getMinExclusive();
  362|     13|    int       baseFixed = numBase->getFixed();
  363|       |
  364|       |                //                                     this
  365|       |                //                 minExclusive                          maxExclusive
  366|       |                //                    minInclusive                  maxInclusive
  367|       |                //
  368|       |                //                                     base
  369|       |                //  minExclusive                                                          maxExclusive
  370|       |                //      minInclusive                                                   maxInclusive
  371|       |                //
  372|       |
  373|       |    // check 4.3.7.c2 error:
  374|       |    // maxInclusive > base.maxInclusive && maxInclusive != base.maxInclusive if (base.fixed)
  375|       |    // maxInclusive >= base.maxExclusive
  376|       |    // maxInclusive < base.minInclusive
  377|       |    // maxInclusive <= base.minExclusive
  378|       |
  379|     13|    if ((thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  ------------------
  |  Branch (379:9): [True: 10, False: 3]
  ------------------
  380|     10|    {
  381|     10|        if ((baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  ------------------
  |  Branch (381:13): [True: 7, False: 3]
  ------------------
  382|      7|        {
  383|      7|            int result = compareValues(thisMaxInclusive, baseMaxInclusive);
  384|       |
  385|      7|            if (((baseFixed & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  ------------------
  |  Branch (385:17): [True: 0, False: 7]
  ------------------
  386|      7|                 (result != 0 ))
  ------------------
  |  Branch (386:18): [True: 0, False: 0]
  ------------------
  387|      0|            {
  388|      0|                REPORT_FACET_ERROR(thisMaxInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  389|      0|                                 , baseMaxInclusive
  390|      0|                                 , XMLExcepts::FACET_maxIncl_base_fixed
  391|      0|                                 , manager)
  392|      0|            }
  393|       |
  394|      7|            if (result == 1 || result == INDETERMINATE)
  ------------------
  |  Branch (394:17): [True: 0, False: 7]
  |  Branch (394:32): [True: 0, False: 7]
  ------------------
  395|      0|            {
  396|      0|                REPORT_FACET_ERROR(thisMaxInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  397|      0|                                 , baseMaxInclusive
  398|      0|                                 , XMLExcepts::FACET_maxIncl_base_maxIncl
  399|      0|                                 , manager)
  400|      0|            }
  401|       |
  402|      7|        }
  403|       |
  404|     10|        if ((baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  ------------------
  |  Branch (404:13): [True: 0, False: 10]
  ------------------
  405|      0|        {
  406|      0|            int result = compareValues(thisMaxInclusive, baseMaxExclusive);
  407|      0|            if (result != -1 )
  ------------------
  |  Branch (407:17): [True: 0, False: 0]
  ------------------
  408|      0|            {
  409|      0|                REPORT_FACET_ERROR(thisMaxInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  410|      0|                                 , baseMaxExclusive
  411|      0|                                 , XMLExcepts::FACET_maxIncl_base_maxExcl
  412|      0|                                 , manager)
  413|      0|            }
  414|      0|        }
  415|       |
  416|       |
  417|     10|        if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  ------------------
  |  Branch (417:13): [True: 7, False: 3]
  ------------------
  418|      7|        {
  419|      7|            int result = compareValues(thisMaxInclusive, baseMinInclusive);
  420|      7|            if (result == -1 || result == INDETERMINATE)
  ------------------
  |  Branch (420:17): [True: 0, False: 7]
  |  Branch (420:33): [True: 0, False: 7]
  ------------------
  421|      0|            {
  422|      0|                REPORT_FACET_ERROR(thisMaxInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  423|      0|                                 , baseMinInclusive
  424|      0|                                 , XMLExcepts::FACET_maxIncl_base_minIncl
  425|      0|                                 , manager)
  426|      0|            }
  427|      7|        }
  428|       |
  429|     10|        if ((baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  ------------------
  |  Branch (429:13): [True: 0, False: 10]
  ------------------
  430|      0|        {
  431|      0|            int result = compareValues(thisMaxInclusive, baseMinExclusive);
  432|      0|            if (result != 1 )
  ------------------
  |  Branch (432:17): [True: 0, False: 0]
  ------------------
  433|      0|            {
  434|      0|                REPORT_FACET_ERROR(thisMaxInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  435|      0|                                 , baseMinExclusive
  436|      0|                                 , XMLExcepts::FACET_maxIncl_base_minExcl
  437|      0|                                 , manager)
  438|      0|            }
  439|      0|        }
  440|       |
  441|     10|    }
  442|       |
  443|       |    // check 4.3.8.c3 error:
  444|       |    // maxExclusive > base.maxExclusive  && maxExclusive != base.maxExclusive if (base.fixed)
  445|       |    // maxExclusive > base.maxInclusive
  446|       |    // maxExclusive <= base.minInclusive
  447|       |    // maxExclusive <= base.minExclusive
  448|       |
  449|     13|    if ((thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  ------------------
  |  Branch (449:9): [True: 0, False: 13]
  ------------------
  450|      0|    {
  451|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  ------------------
  |  Branch (451:13): [True: 0, False: 0]
  ------------------
  452|      0|        {
  453|      0|            int result = compareValues(thisMaxExclusive, baseMaxExclusive);
  454|       |
  455|      0|            if (((baseFixed & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (455:17): [True: 0, False: 0]
  ------------------
  456|      0|                 (result != 0 ))
  ------------------
  |  Branch (456:18): [True: 0, False: 0]
  ------------------
  457|      0|            {
  458|      0|                REPORT_FACET_ERROR(thisMaxExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  459|      0|                                 , baseMaxExclusive
  460|      0|                                 , XMLExcepts::FACET_maxExcl_base_fixed
  461|      0|                                 , manager)
  462|      0|             }
  463|       |
  464|      0|            if (result == 1 || result == INDETERMINATE)
  ------------------
  |  Branch (464:17): [True: 0, False: 0]
  |  Branch (464:32): [True: 0, False: 0]
  ------------------
  465|      0|            {
  466|      0|                REPORT_FACET_ERROR(thisMaxExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  467|      0|                                 , baseMaxExclusive
  468|      0|                                 , XMLExcepts::FACET_maxExcl_base_maxExcl
  469|      0|                                 , manager)
  470|      0|            }
  471|       |
  472|       |            /**
  473|       |             * Schema Errata
  474|       |             * E2-16 maxExclusive
  475|       |             *
  476|       |             *   derived type's maxExclusive must either be
  477|       |             *   1) equal to base' maxExclusive or
  478|       |             *   2) from the base type value space
  479|       |             *
  480|       |             */
  481|      0|            if (result != 0)
  ------------------
  |  Branch (481:17): [True: 0, False: 0]
  ------------------
  482|      0|            {
  483|      0|                FROM_BASE_VALUE_SPACE(thisMaxExclusive
  ------------------
  |  |   50|      0|  if ((thisFacetsDefined & facetFlag) != 0)                   \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|{                                                             \
  |  |   52|      0|    try                                                       \
  |  |   53|      0|{                                                             \
  |  |   54|      0|        numBase->checkContent(val->getRawData(), (ValidationContext*)0, false, manager);      \
  |  |   55|      0|}                                                             \
  |  |   56|      0|    catch ( XMLException& )                                   \
  |  |   57|      0|{                                                             \
  |  |   58|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |   59|      0|                , except_code                                 \
  |  |   60|      0|                , val->getRawData()                           \
  |  |   61|      0|                , manager);                                   \
  |  |   62|      0|}                                                             \
  |  |   63|      0|}
  ------------------
  484|      0|                        , DatatypeValidator::FACET_MAXEXCLUSIVE
  485|      0|                        , XMLExcepts::FACET_maxExcl_notFromBase
  486|      0|                        , manager)
  487|      0|            }
  488|      0|        }
  489|      0|        else  // base has no maxExclusive
  490|      0|        {
  491|      0|            FROM_BASE_VALUE_SPACE(thisMaxExclusive
  ------------------
  |  |   50|      0|  if ((thisFacetsDefined & facetFlag) != 0)                   \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|{                                                             \
  |  |   52|      0|    try                                                       \
  |  |   53|      0|{                                                             \
  |  |   54|      0|        numBase->checkContent(val->getRawData(), (ValidationContext*)0, false, manager);      \
  |  |   55|      0|}                                                             \
  |  |   56|      0|    catch ( XMLException& )                                   \
  |  |   57|      0|{                                                             \
  |  |   58|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |   59|      0|                , except_code                                 \
  |  |   60|      0|                , val->getRawData()                           \
  |  |   61|      0|                , manager);                                   \
  |  |   62|      0|}                                                             \
  |  |   63|      0|}
  ------------------
  492|      0|                        , DatatypeValidator::FACET_MAXEXCLUSIVE
  493|      0|                        , XMLExcepts::FACET_maxExcl_notFromBase
  494|      0|                        , manager)
  495|      0|        }
  496|       |
  497|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  ------------------
  |  Branch (497:13): [True: 0, False: 0]
  ------------------
  498|      0|        {
  499|      0|            int result = compareValues(thisMaxExclusive, baseMaxInclusive);
  500|      0|            if (result == 1 || result == INDETERMINATE)
  ------------------
  |  Branch (500:17): [True: 0, False: 0]
  |  Branch (500:32): [True: 0, False: 0]
  ------------------
  501|      0|            {
  502|      0|                REPORT_FACET_ERROR(thisMaxExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  503|      0|                                 , baseMaxInclusive
  504|      0|                                 , XMLExcepts::FACET_maxExcl_base_maxIncl
  505|      0|                                 , manager)
  506|      0|            }
  507|      0|        }
  508|       |
  509|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  ------------------
  |  Branch (509:13): [True: 0, False: 0]
  ------------------
  510|      0|        {
  511|      0|            int result = compareValues(thisMaxExclusive, baseMinExclusive);
  512|      0|            if (result != 1)
  ------------------
  |  Branch (512:17): [True: 0, False: 0]
  ------------------
  513|      0|            {
  514|      0|                REPORT_FACET_ERROR(thisMaxExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  515|      0|                                 , baseMinExclusive
  516|      0|                                 , XMLExcepts::FACET_maxExcl_base_minExcl
  517|      0|                                 , manager)
  518|      0|            }
  519|      0|        }
  520|       |
  521|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  ------------------
  |  Branch (521:13): [True: 0, False: 0]
  ------------------
  522|      0|        {
  523|      0|            int result = compareValues(thisMaxExclusive, baseMinInclusive);
  524|      0|            if (result != 1)
  ------------------
  |  Branch (524:17): [True: 0, False: 0]
  ------------------
  525|      0|            {
  526|      0|                REPORT_FACET_ERROR(thisMaxExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  527|      0|                                 , baseMinInclusive
  528|      0|                                 , XMLExcepts::FACET_maxExcl_base_minIncl
  529|      0|                                 , manager)
  530|      0|            }
  531|      0|        }
  532|      0|    }
  533|       |
  534|       |    // check 4.3.9.c3 error:
  535|       |    // minExclusive < base.minExclusive     minExclusive != base.minExclusive if (base.fixed)
  536|       |    // minExclusive > base.maxInclusive ??? minExclusive >= base.maxInclusive
  537|       |    // minExclusive < base.minInclusive
  538|       |    // minExclusive >= base.maxExclusive
  539|       |
  540|     13|    if ((thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  ------------------
  |  Branch (540:9): [True: 0, False: 13]
  ------------------
  541|      0|    {
  542|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  ------------------
  |  Branch (542:13): [True: 0, False: 0]
  ------------------
  543|      0|        {
  544|      0|            int result = compareValues(thisMinExclusive, baseMinExclusive);
  545|       |
  546|      0|            if (((baseFixed & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (546:17): [True: 0, False: 0]
  ------------------
  547|      0|                 (result != 0 ))
  ------------------
  |  Branch (547:18): [True: 0, False: 0]
  ------------------
  548|      0|            {
  549|      0|                REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  550|      0|                                 , baseMinExclusive
  551|      0|                                 , XMLExcepts::FACET_minExcl_base_fixed
  552|      0|                                 , manager)
  553|      0|            }
  554|       |
  555|      0|            if (result == -1 || result == INDETERMINATE)
  ------------------
  |  Branch (555:17): [True: 0, False: 0]
  |  Branch (555:33): [True: 0, False: 0]
  ------------------
  556|      0|            {
  557|      0|                REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  558|      0|                                 , baseMinExclusive
  559|      0|                                 , XMLExcepts::FACET_minExcl_base_minExcl
  560|      0|                                 , manager)
  561|      0|            }
  562|       |
  563|       |            /**
  564|       |             * Schema Errata
  565|       |             * E2-16 maxExclusive
  566|       |             *
  567|       |             *   derived type's minExclusive must either be
  568|       |             *   1) equal to base' minxExclusive or
  569|       |             *   2) from the base type value space
  570|       |             *
  571|       |             *  Note: deduced from, not explicitly expressed in the Errata
  572|       |             */
  573|      0|            if (result != 0)
  ------------------
  |  Branch (573:17): [True: 0, False: 0]
  ------------------
  574|      0|            {
  575|      0|                FROM_BASE_VALUE_SPACE(thisMinExclusive
  ------------------
  |  |   50|      0|  if ((thisFacetsDefined & facetFlag) != 0)                   \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|{                                                             \
  |  |   52|      0|    try                                                       \
  |  |   53|      0|{                                                             \
  |  |   54|      0|        numBase->checkContent(val->getRawData(), (ValidationContext*)0, false, manager);      \
  |  |   55|      0|}                                                             \
  |  |   56|      0|    catch ( XMLException& )                                   \
  |  |   57|      0|{                                                             \
  |  |   58|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |   59|      0|                , except_code                                 \
  |  |   60|      0|                , val->getRawData()                           \
  |  |   61|      0|                , manager);                                   \
  |  |   62|      0|}                                                             \
  |  |   63|      0|}
  ------------------
  576|      0|                        , DatatypeValidator::FACET_MINEXCLUSIVE
  577|      0|                        , XMLExcepts::FACET_minExcl_notFromBase
  578|      0|                        , manager)
  579|      0|            }
  580|      0|        }
  581|      0|        else // base has no minExclusive
  582|      0|        {
  583|       |
  584|      0|            FROM_BASE_VALUE_SPACE(thisMinExclusive
  ------------------
  |  |   50|      0|  if ((thisFacetsDefined & facetFlag) != 0)                   \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|{                                                             \
  |  |   52|      0|    try                                                       \
  |  |   53|      0|{                                                             \
  |  |   54|      0|        numBase->checkContent(val->getRawData(), (ValidationContext*)0, false, manager);      \
  |  |   55|      0|}                                                             \
  |  |   56|      0|    catch ( XMLException& )                                   \
  |  |   57|      0|{                                                             \
  |  |   58|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |   59|      0|                , except_code                                 \
  |  |   60|      0|                , val->getRawData()                           \
  |  |   61|      0|                , manager);                                   \
  |  |   62|      0|}                                                             \
  |  |   63|      0|}
  ------------------
  585|      0|                        , DatatypeValidator::FACET_MINEXCLUSIVE
  586|      0|                        , XMLExcepts::FACET_minExcl_notFromBase
  587|      0|                        , manager)
  588|      0|        }
  589|       |
  590|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  ------------------
  |  Branch (590:13): [True: 0, False: 0]
  ------------------
  591|      0|        {
  592|      0|            int result = compareValues(thisMinExclusive, baseMaxInclusive);
  593|      0|            if (result == 1 || result == INDETERMINATE)
  ------------------
  |  Branch (593:17): [True: 0, False: 0]
  |  Branch (593:32): [True: 0, False: 0]
  ------------------
  594|      0|            {
  595|      0|                REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  596|      0|                                 , baseMaxInclusive
  597|      0|                                 , XMLExcepts::FACET_minExcl_base_maxIncl
  598|      0|                                 , manager)
  599|      0|            }
  600|      0|        }
  601|       |
  602|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  ------------------
  |  Branch (602:13): [True: 0, False: 0]
  ------------------
  603|      0|        {
  604|      0|            int result = compareValues(thisMinExclusive, baseMinInclusive);
  605|      0|            if (result == -1 || result == INDETERMINATE)
  ------------------
  |  Branch (605:17): [True: 0, False: 0]
  |  Branch (605:33): [True: 0, False: 0]
  ------------------
  606|      0|            {
  607|      0|                REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  608|      0|                                 , baseMinInclusive
  609|      0|                                 , XMLExcepts::FACET_minExcl_base_minIncl
  610|      0|                                 , manager)
  611|      0|            }
  612|      0|        }
  613|       |
  614|      0|        if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  ------------------
  |  Branch (614:13): [True: 0, False: 0]
  ------------------
  615|      0|        {
  616|      0|            int result = compareValues(thisMinExclusive, baseMaxExclusive);
  617|      0|            if (result != -1)
  ------------------
  |  Branch (617:17): [True: 0, False: 0]
  ------------------
  618|      0|            {
  619|      0|                REPORT_FACET_ERROR(thisMinExclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  620|      0|                                 , baseMaxExclusive
  621|      0|                                 , XMLExcepts::FACET_minExcl_base_maxExcl
  622|      0|                                 , manager)
  623|      0|            }
  624|      0|        }
  625|       |
  626|      0|    }
  627|       |
  628|       |    // check 4.3.10.c2 error:
  629|       |    // minInclusive < base.minInclusive   minInclusive != base.minInclusive if (base.fixed)
  630|       |    // minInclusive > base.maxInclusive
  631|       |    // minInclusive <= base.minExclusive
  632|       |    // minInclusive >= base.maxExclusive
  633|       |
  634|       |
  635|     13|    if ((thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  ------------------
  |  Branch (635:9): [True: 6, False: 7]
  ------------------
  636|      6|    {
  637|      6|        if ((baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0)
  ------------------
  |  Branch (637:13): [True: 4, False: 2]
  ------------------
  638|      4|        {
  639|      4|            int result = compareValues(thisMinInclusive, baseMinInclusive);
  640|       |
  641|      4|            if (((baseFixed & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
  ------------------
  |  Branch (641:17): [True: 0, False: 4]
  ------------------
  642|      4|                 (result != 0 ))
  ------------------
  |  Branch (642:18): [True: 0, False: 0]
  ------------------
  643|      0|            {
  644|      0|                REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  645|      0|                                 , baseMinInclusive
  646|      0|                                 , XMLExcepts::FACET_minIncl_base_fixed
  647|      0|                                 , manager)
  648|      0|            }
  649|       |
  650|      4|            if (result == -1 || result == INDETERMINATE)
  ------------------
  |  Branch (650:17): [True: 0, False: 4]
  |  Branch (650:33): [True: 0, False: 4]
  ------------------
  651|      0|            {
  652|      0|                REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  653|      0|                                 , baseMinInclusive
  654|      0|                                 , XMLExcepts::FACET_minIncl_base_minIncl
  655|      0|                                 , manager)
  656|      0|            }
  657|      4|        }
  658|       |
  659|      6|        if (( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0)
  ------------------
  |  Branch (659:13): [True: 3, False: 3]
  ------------------
  660|      3|        {
  661|      3|            int result = compareValues(thisMinInclusive, baseMaxInclusive);
  662|      3|            if (result == 1 || result == INDETERMINATE)
  ------------------
  |  Branch (662:17): [True: 0, False: 3]
  |  Branch (662:32): [True: 0, False: 3]
  ------------------
  663|      0|            {
  664|      0|                REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  665|      0|                                 , baseMaxInclusive
  666|      0|                                 , XMLExcepts::FACET_minIncl_base_maxIncl
  667|      0|                                 , manager)
  668|      0|            }
  669|      3|        }
  670|       |
  671|      6|        if (( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0)
  ------------------
  |  Branch (671:13): [True: 0, False: 6]
  ------------------
  672|      0|        {
  673|      0|            int result = compareValues(thisMinInclusive, baseMinExclusive);
  674|      0|            if (result != 1)
  ------------------
  |  Branch (674:17): [True: 0, False: 0]
  ------------------
  675|      0|            {
  676|      0|                REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  677|      0|                                 , baseMinExclusive
  678|      0|                                 , XMLExcepts::FACET_minIncl_base_minExcl
  679|      0|                                 , manager)
  680|      0|            }
  681|      0|        }
  682|       |
  683|      6|        if (( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0)
  ------------------
  |  Branch (683:13): [True: 0, False: 6]
  ------------------
  684|      0|        {
  685|      0|            int result = compareValues(thisMinInclusive, baseMaxExclusive);
  686|      0|            if (result != -1)
  ------------------
  |  Branch (686:17): [True: 0, False: 0]
  ------------------
  687|      0|            {
  688|      0|                REPORT_FACET_ERROR(thisMinInclusive
  ------------------
  |  |   43|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   44|      0|          , except_code                                 \
  |  |   45|      0|          , val1->getFormattedString()                  \
  |  |   46|      0|          , val2->getFormattedString()                  \
  |  |   47|      0|          , manager);
  ------------------
  689|      0|                                 , baseMaxExclusive
  690|      0|                                 , XMLExcepts::FACET_minIncl_base_maxExcl
  691|      0|                                 , manager)
  692|      0|            }
  693|      0|        }
  694|       |
  695|      6|    }
  696|       |
  697|     13|    checkAdditionalFacetConstraintsBase(manager);
  698|       |
  699|       |    // check 4.3.5.c0 must: enumeration values from the value space of base
  700|       |    //
  701|       |    // In fact, the values in the enumeration shall go through validation
  702|       |    // of this class as well.
  703|       |    // this->checkContent(value, false);
  704|       |    //
  705|     13|    if ( ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  ------------------
  |  Branch (705:10): [True: 0, False: 13]
  ------------------
  706|     13|        ( fStrEnumeration ))
  ------------------
  |  Branch (706:9): [True: 0, False: 0]
  ------------------
  707|      0|    {
  708|      0|        setEnumeration(manager);
  709|      0|    }
  710|       |
  711|       |    //
  712|       |    // maxInclusive, maxExclusive, minInclusive and minExclusive
  713|       |    // shall come from the base's value space as well
  714|       |    //
  715|       |
  716|     13|    FROM_BASE_VALUE_SPACE(thisMaxInclusive
  ------------------
  |  |   50|     13|  if ((thisFacetsDefined & facetFlag) != 0)                   \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 10, False: 3]
  |  |  ------------------
  |  |   51|     10|{                                                             \
  |  |   52|     10|    try                                                       \
  |  |   53|     10|{                                                             \
  |  |   54|     10|        numBase->checkContent(val->getRawData(), (ValidationContext*)0, false, manager);      \
  |  |   55|     10|}                                                             \
  |  |   56|     10|    catch ( XMLException& )                                   \
  |  |   57|      0|{                                                             \
  |  |   58|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |   59|      0|                , except_code                                 \
  |  |   60|      0|                , val->getRawData()                           \
  |  |   61|      0|                , manager);                                   \
  |  |   62|      0|}                                                             \
  |  |   63|     10|}
  ------------------
  717|     13|                        , DatatypeValidator::FACET_MAXINCLUSIVE
  718|     13|                        , XMLExcepts::FACET_maxIncl_notFromBase
  719|     13|                        , manager)
  720|       |
  721|     13|    FROM_BASE_VALUE_SPACE(thisMinInclusive
  ------------------
  |  |   50|     13|  if ((thisFacetsDefined & facetFlag) != 0)                   \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 6, False: 7]
  |  |  ------------------
  |  |   51|      6|{                                                             \
  |  |   52|      6|    try                                                       \
  |  |   53|      6|{                                                             \
  |  |   54|      6|        numBase->checkContent(val->getRawData(), (ValidationContext*)0, false, manager);      \
  |  |   55|      6|}                                                             \
  |  |   56|      6|    catch ( XMLException& )                                   \
  |  |   57|      0|{                                                             \
  |  |   58|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException               \
  |  |  ------------------
  |  |  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  |  |  ------------------
  |  |   59|      0|                , except_code                                 \
  |  |   60|      0|                , val->getRawData()                           \
  |  |   61|      0|                , manager);                                   \
  |  |   62|      0|}                                                             \
  |  |   63|      6|}
  ------------------
  722|     13|                        , DatatypeValidator::FACET_MININCLUSIVE
  723|     13|                        , XMLExcepts::FACET_minIncl_notFromBase
  724|     13|                        , manager)
  725|       |
  726|     13|} //end of inspectFacetBase
_ZN11xercesc_3_229AbstractNumericFacetValidator12inheritFacetEv:
  734|     13|{
  735|       |
  736|     13|    AbstractNumericFacetValidator* numBase = (AbstractNumericFacetValidator*) getBaseValidator();
  737|     13|    if (!numBase)
  ------------------
  |  Branch (737:9): [True: 0, False: 13]
  ------------------
  738|      0|        return;
  739|       |
  740|     13|    int thisFacetsDefined = getFacetsDefined();
  741|     13|    int baseFacetsDefined = numBase->getFacetsDefined();
  742|       |
  743|       |    // inherit enumeration
  744|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  ------------------
  |  Branch (744:9): [True: 0, False: 13]
  ------------------
  745|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) == 0))
  ------------------
  |  Branch (745:9): [True: 0, False: 0]
  ------------------
  746|      0|    {
  747|      0|        fEnumeration = numBase->fEnumeration;
  748|      0|        fEnumerationInherited = true;
  749|      0|        setFacetsDefined(DatatypeValidator::FACET_ENUMERATION);
  750|      0|    }
  751|       |
  752|       |    // inherit maxInclusive
  753|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0) &&
  ------------------
  |  Branch (753:9): [True: 7, False: 6]
  ------------------
  754|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
  ------------------
  |  Branch (754:9): [True: 7, False: 0]
  ------------------
  755|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
  ------------------
  |  Branch (755:9): [True: 0, False: 7]
  ------------------
  756|      0|    {
  757|      0|        fMaxInclusive = numBase->getMaxInclusive();
  758|      0|        fMaxInclusiveInherited = true;
  759|      0|        setFacetsDefined(DatatypeValidator::FACET_MAXINCLUSIVE);
  760|      0|    }
  761|       |
  762|       |    // inherit maxExclusive
  763|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (763:9): [True: 0, False: 13]
  ------------------
  764|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) == 0) &&
  ------------------
  |  Branch (764:9): [True: 0, False: 0]
  ------------------
  765|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) == 0) )
  ------------------
  |  Branch (765:9): [True: 0, False: 0]
  ------------------
  766|      0|    {
  767|      0|        fMaxExclusive = numBase->getMaxExclusive();
  768|      0|        fMaxExclusiveInherited = true;
  769|      0|        setFacetsDefined(DatatypeValidator::FACET_MAXEXCLUSIVE);
  770|      0|    }
  771|       |
  772|       |    // inherit minExclusive
  773|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0) &&
  ------------------
  |  Branch (773:9): [True: 8, False: 5]
  ------------------
  774|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
  ------------------
  |  Branch (774:9): [True: 8, False: 0]
  ------------------
  775|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
  ------------------
  |  Branch (775:9): [True: 4, False: 4]
  ------------------
  776|      4|    {
  777|      4|        fMinInclusive = numBase->getMinInclusive();
  778|      4|        fMinInclusiveInherited = true;
  779|      4|        setFacetsDefined(DatatypeValidator::FACET_MININCLUSIVE);
  780|      4|    }
  781|       |
  782|       |    // inherit minExclusive
  783|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0) &&
  ------------------
  |  Branch (783:9): [True: 0, False: 13]
  ------------------
  784|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) == 0) &&
  ------------------
  |  Branch (784:9): [True: 0, False: 0]
  ------------------
  785|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) == 0) )
  ------------------
  |  Branch (785:9): [True: 0, False: 0]
  ------------------
  786|      0|    {
  787|      0|        fMinExclusive = numBase->getMinExclusive();
  788|      0|        fMinExclusiveInherited = true;
  789|      0|        setFacetsDefined(DatatypeValidator::FACET_MINEXCLUSIVE);
  790|      0|    }
  791|       |
  792|     13|    inheritAdditionalFacet();
  793|       |
  794|       |    // inherit "fixed" option
  795|     13|    setFixed(getFixed() | numBase->getFixed());
  796|       |
  797|     13|}

_ZNK11xercesc_3_229AbstractNumericFacetValidator15getMaxInclusiveEv:
  171|     49|{
  172|     49|    return fMaxInclusive;
  173|     49|}
_ZNK11xercesc_3_229AbstractNumericFacetValidator15getMaxExclusiveEv:
  176|     39|{
  177|     39|    return fMaxExclusive;
  178|     39|}
_ZNK11xercesc_3_229AbstractNumericFacetValidator15getMinInclusiveEv:
  181|     54|{
  182|     54|    return fMinInclusive;
  183|     54|}
_ZNK11xercesc_3_229AbstractNumericFacetValidator15getMinExclusiveEv:
  186|     39|{
  187|     39|    return fMinExclusive;
  188|     39|}
_ZNK11xercesc_3_229AbstractNumericFacetValidator14getEnumerationEv:
  191|     16|{
  192|     16|    return fEnumeration;
  193|     16|}

_ZN11xercesc_3_224AbstractNumericValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEiNS1_13ValidatorTypeEPNS_13MemoryManagerE:
   51|     16|{
   52|       |    //do not invoke init() here !!!
   53|     16|}
_ZN11xercesc_3_224AbstractNumericValidator11boundsCheckEPKNS_9XMLNumberEPNS_13MemoryManagerE:
   64|     16|{
   65|     16|    int thisFacetsDefined = getFacetsDefined();
   66|     16|    int result;
   67|       |
   68|     16|    if (thisFacetsDefined == 0)
  ------------------
  |  Branch (68:9): [True: 0, False: 16]
  ------------------
   69|      0|        return;
   70|       |
   71|       |    // must be < MaxExclusive
   72|     16|    if ( (thisFacetsDefined & DatatypeValidator::FACET_MAXEXCLUSIVE) != 0 )
  ------------------
  |  Branch (72:10): [True: 0, False: 16]
  ------------------
   73|      0|    {
   74|      0|        result = compareValues(theData, getMaxExclusive());
   75|      0|        if ( result != -1)
  ------------------
  |  Branch (75:14): [True: 0, False: 0]
  ------------------
   76|      0|        {
   77|      0|            REPORT_VALUE_ERROR(theData
  ------------------
  |  |   32|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeValueException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   33|      0|          , except_code                                 \
  |  |   34|      0|          , val1->getFormattedString()                  \
  |  |   35|      0|          , val2->getFormattedString()                  \
  |  |   36|      0|          , manager);
  ------------------
   78|      0|                                 , getMaxExclusive()
   79|      0|                                 , XMLExcepts::VALUE_exceed_maxExcl
   80|      0|                                 , manager)
   81|      0|        }
   82|      0|    } 	
   83|       |
   84|       |    // must be <= MaxInclusive
   85|     16|    if ( (thisFacetsDefined & DatatypeValidator::FACET_MAXINCLUSIVE) != 0 )
  ------------------
  |  Branch (85:10): [True: 10, False: 6]
  ------------------
   86|     10|    {
   87|     10|        result = compareValues(theData, getMaxInclusive());
   88|     10|        if (result == 1)
  ------------------
  |  Branch (88:13): [True: 0, False: 10]
  ------------------
   89|      0|        {
   90|      0|            REPORT_VALUE_ERROR(theData
  ------------------
  |  |   32|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeValueException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   33|      0|          , except_code                                 \
  |  |   34|      0|          , val1->getFormattedString()                  \
  |  |   35|      0|          , val2->getFormattedString()                  \
  |  |   36|      0|          , manager);
  ------------------
   91|      0|                             , getMaxInclusive()
   92|      0|                             , XMLExcepts::VALUE_exceed_maxIncl
   93|      0|                             , manager)
   94|      0|        }
   95|     10|    }
   96|       |
   97|       |    // must be >= MinInclusive
   98|     16|    if ( (thisFacetsDefined & DatatypeValidator::FACET_MININCLUSIVE) != 0 )
  ------------------
  |  Branch (98:10): [True: 11, False: 5]
  ------------------
   99|     11|    {
  100|     11|        result = compareValues(theData, getMinInclusive());
  101|     11|        if (result == -1)
  ------------------
  |  Branch (101:13): [True: 0, False: 11]
  ------------------
  102|      0|        {
  103|      0|            REPORT_VALUE_ERROR(theData
  ------------------
  |  |   32|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeValueException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   33|      0|          , except_code                                 \
  |  |   34|      0|          , val1->getFormattedString()                  \
  |  |   35|      0|          , val2->getFormattedString()                  \
  |  |   36|      0|          , manager);
  ------------------
  104|      0|                             , getMinInclusive()
  105|      0|                             , XMLExcepts::VALUE_exceed_minIncl
  106|      0|                             , manager)
  107|      0|        }
  108|     11|    }
  109|       |
  110|       |    // must be > MinExclusive
  111|     16|    if ( (thisFacetsDefined & DatatypeValidator::FACET_MINEXCLUSIVE) != 0 )
  ------------------
  |  Branch (111:10): [True: 0, False: 16]
  ------------------
  112|      0|    {
  113|      0|        result = compareValues(theData, getMinExclusive());
  114|      0|        if (result != 1)
  ------------------
  |  Branch (114:13): [True: 0, False: 0]
  ------------------
  115|      0|        {
  116|      0|            REPORT_VALUE_ERROR(theData
  ------------------
  |  |   32|      0|  ThrowXMLwithMemMgr2(InvalidDatatypeValueException               \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   33|      0|          , except_code                                 \
  |  |   34|      0|          , val1->getFormattedString()                  \
  |  |   35|      0|          , val2->getFormattedString()                  \
  |  |   36|      0|          , manager);
  ------------------
  117|      0|                             , getMinExclusive()
  118|      0|                             , XMLExcepts::VALUE_exceed_minExcl
  119|      0|                             , manager)
  120|      0|        }
  121|      0|    }
  122|     16|}

_ZN11xercesc_3_224AbstractNumericValidator4initEPNS_16RefArrayVectorOfIDsEEPNS_13MemoryManagerE:
   99|     13|{
  100|     13|    AbstractNumericFacetValidator::init(enums, manager);
  101|     13|}

_ZN11xercesc_3_223AbstractStringValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEiNS1_13ValidatorTypeEPNS_13MemoryManagerE:
   84|     18|{
   85|       |    // init() is invoked from derived class's ctor instead of from
   86|       |    // here to allow correct resolution of virutal method, such as
   87|       |    // assigneAdditionalFacet(), inheritAdditionalFacet().
   88|     18|}
_ZN11xercesc_3_223AbstractStringValidator4initEPNS_16RefArrayVectorOfIDsEEPNS_13MemoryManagerE:
   92|     12|{
   93|       |
   94|     12|    if (enums)
  ------------------
  |  Branch (94:9): [True: 0, False: 12]
  ------------------
   95|      0|    {
   96|      0|        setEnumeration(enums, false);
   97|      0|        normalizeEnumeration(manager);
   98|      0|    }
   99|       |
  100|     12|    assignFacet(manager);
  101|     12|    inspectFacet(manager);
  102|     12|    inspectFacetBase(manager);
  103|     12|    inheritFacet();
  104|       |
  105|     12|}
_ZN11xercesc_3_223AbstractStringValidator11assignFacetEPNS_13MemoryManagerE:
  113|     12|{
  114|       |
  115|     12|    RefHashTableOf<KVStringPair>* facets = getFacets();
  116|       |
  117|     12|    if (!facets)
  ------------------
  |  Branch (117:9): [True: 5, False: 7]
  ------------------
  118|      5|        return;
  119|       |
  120|      7|    XMLCh* key;
  121|      7|    RefHashTableOfEnumerator<KVStringPair> e(facets, false, manager);
  122|       |
  123|     15|    while (e.hasMoreElements())
  ------------------
  |  Branch (123:12): [True: 8, False: 7]
  ------------------
  124|      8|    {
  125|      8|        KVStringPair pair = e.nextElement();
  126|      8|        key = pair.getKey();
  127|      8|        XMLCh* value = pair.getValue();
  128|       |
  129|      8|        if (XMLString::equals(key, SchemaSymbols::fgELT_LENGTH))
  ------------------
  |  Branch (129:13): [True: 0, False: 8]
  ------------------
  130|      0|        {
  131|      0|            int val;
  132|      0|            try
  133|      0|            {
  134|      0|                val = XMLString::parseInt(value, manager);
  135|      0|            }
  136|      0|            catch (NumberFormatException&)
  137|      0|            {
  138|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_Len, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  139|      0|            }
  140|       |
  141|      0|            if ( val < 0 )
  ------------------
  |  Branch (141:18): [True: 0, False: 0]
  ------------------
  142|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_Len, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  143|       |
  144|      0|            setLength(val);
  145|      0|            setFacetsDefined(DatatypeValidator::FACET_LENGTH);
  146|      0|        }
  147|      8|        else if (XMLString::equals(key, SchemaSymbols::fgELT_MINLENGTH))
  ------------------
  |  Branch (147:18): [True: 3, False: 5]
  ------------------
  148|      3|        {
  149|      3|            int val;
  150|      3|            try
  151|      3|            {
  152|      3|                val = XMLString::parseInt(value, manager);
  153|      3|            }
  154|      3|            catch (NumberFormatException&)
  155|      3|            {
  156|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_minLen, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  157|      0|            }
  158|       |
  159|      3|            if ( val < 0 )
  ------------------
  |  Branch (159:18): [True: 0, False: 3]
  ------------------
  160|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_minLen, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  161|       |
  162|      3|            setMinLength(val);
  163|      3|            setFacetsDefined(DatatypeValidator::FACET_MINLENGTH);
  164|      3|        }
  165|      5|        else if (XMLString::equals(key, SchemaSymbols::fgELT_MAXLENGTH))
  ------------------
  |  Branch (165:18): [True: 0, False: 5]
  ------------------
  166|      0|        {
  167|      0|            int val;
  168|      0|            try
  169|      0|            {
  170|      0|                val = XMLString::parseInt(value, manager);
  171|      0|            }
  172|      0|            catch (NumberFormatException&)
  173|      0|            {
  174|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_maxLen, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  175|      0|            }
  176|       |
  177|      0|            if ( val < 0 )
  ------------------
  |  Branch (177:18): [True: 0, False: 0]
  ------------------
  178|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_maxLen, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  179|       |
  180|      0|            setMaxLength(val);
  181|      0|            setFacetsDefined(DatatypeValidator::FACET_MAXLENGTH);
  182|      0|        }
  183|      5|        else if (XMLString::equals(key, SchemaSymbols::fgELT_PATTERN))
  ------------------
  |  Branch (183:18): [True: 2, False: 3]
  ------------------
  184|      2|        {
  185|      2|            setPattern(value);
  186|      2|            if (getPattern())
  ------------------
  |  Branch (186:17): [True: 2, False: 0]
  ------------------
  187|      2|                setFacetsDefined(DatatypeValidator::FACET_PATTERN);
  188|       |            // do not construct regex until needed
  189|      2|        }
  190|      3|        else if (XMLString::equals(key, SchemaSymbols::fgATT_FIXED))
  ------------------
  |  Branch (190:18): [True: 0, False: 3]
  ------------------
  191|      0|        {
  192|      0|            unsigned int val;
  193|      0|            bool         retStatus;
  194|      0|            try
  195|      0|            {
  196|      0|                retStatus = XMLString::textToBin(value, val, fMemoryManager);
  197|      0|            }
  198|      0|            catch (RuntimeException&)
  199|      0|            {
  200|      0|                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  201|      0|            }
  202|       |
  203|      0|            if (!retStatus)
  ------------------
  |  Branch (203:17): [True: 0, False: 0]
  ------------------
  204|      0|            {
  205|      0|                ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_internalError_fixed, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  206|      0|            }
  207|       |
  208|      0|            setFixed(val);
  209|       |            //no setFacetsDefined here
  210|      0|        }
  211|       |        //
  212|       |        // else if (XMLString::equals(key, SchemaSymbols::fgELT_SPECIAL_TOKEN))
  213|       |        // TODO
  214|       |        //
  215|       |        // Note: whitespace is taken care of by TraverseSchema.
  216|       |        //
  217|      3|        else
  218|      3|        {
  219|      3|            assignAdditionalFacet(key, value, manager);
  220|      3|        }
  221|      8|    }//while
  222|      7|}//end of assigneFacet()
_ZN11xercesc_3_223AbstractStringValidator12inspectFacetEPNS_13MemoryManagerE:
  230|     12|{
  231|       |
  232|     12|    int thisFacetsDefined = getFacetsDefined();
  233|       |
  234|     12|    if (!thisFacetsDefined)
  ------------------
  |  Branch (234:9): [True: 5, False: 7]
  ------------------
  235|      5|        return;
  236|       |
  237|       |    // check 4.3.1.c1 error: length & (maxLength | minLength)
  238|      7|    if ((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) != 0)
  ------------------
  |  Branch (238:9): [True: 0, False: 7]
  ------------------
  239|      0|    {
  240|      0|        if ((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) != 0)
  ------------------
  |  Branch (240:13): [True: 0, False: 0]
  ------------------
  241|      0|            ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_Len_maxLen, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  242|      0|        else if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) != 0))
  ------------------
  |  Branch (242:18): [True: 0, False: 0]
  ------------------
  243|      0|            ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_Len_minLen, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  244|      0|    }
  245|       |
  246|       |    // check 4.3.2.c1 must: minLength <= maxLength
  247|      7|    if ((thisFacetsDefined & (DatatypeValidator::FACET_MINLENGTH
  ------------------
  |  Branch (247:9): [True: 3, False: 4]
  ------------------
  248|      7|        |DatatypeValidator::FACET_MAXLENGTH)) != 0)
  249|      3|    {
  250|      3|        XMLSize_t thisMinLength = getMinLength();
  251|      3|        XMLSize_t thisMaxLength = getMaxLength();
  252|      3|        if ( thisMinLength > thisMaxLength )
  ------------------
  |  Branch (252:14): [True: 0, False: 3]
  ------------------
  253|      0|        {
  254|      0|            REPORT_FACET_ERROR(thisMaxLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  255|      0|                             , thisMinLength
  256|      0|                             , XMLExcepts::FACET_maxLen_minLen
  257|      0|                             , manager)
  258|      0|        }
  259|      3|    }
  260|       |
  261|      7|}// end of inspectFacet()
_ZN11xercesc_3_223AbstractStringValidator16inspectFacetBaseEPNS_13MemoryManagerE:
  270|      9|{
  271|       |
  272|      9|    AbstractStringValidator *pBaseValidator = (AbstractStringValidator*) getBaseValidator();
  273|      9|    int thisFacetsDefined = getFacetsDefined();
  274|       |
  275|      9|    if ( (!thisFacetsDefined && !fEnumeration) ||
  ------------------
  |  Branch (275:11): [True: 5, False: 4]
  |  Branch (275:33): [True: 5, False: 0]
  ------------------
  276|      9|         (!pBaseValidator)                      )
  ------------------
  |  Branch (276:10): [True: 0, False: 4]
  ------------------
  277|      5|        return;
  278|       |
  279|      4|    int baseFacetsDefined = pBaseValidator->getFacetsDefined();
  280|       |
  281|      4|    XMLSize_t thisLength    = getLength();
  282|      4|    XMLSize_t thisMinLength = getMinLength();
  283|      4|    XMLSize_t thisMaxLength = getMaxLength();
  284|       |
  285|      4|    XMLSize_t baseLength    = pBaseValidator->getLength();
  286|      4|    XMLSize_t baseMinLength = pBaseValidator->getMinLength();
  287|      4|    XMLSize_t baseMaxLength = pBaseValidator->getMaxLength();
  288|      4|    int baseFixed     = pBaseValidator->getFixed();
  289|       |
  290|       |    /***
  291|       |       check facets against base.facets
  292|       |       Note: later we need to check the "fix" option of the base type
  293|       |            and apply that to every individual facet.
  294|       |    ***/
  295|       |
  296|       |    /***
  297|       |                Non coexistence of derived' length and base'    (minLength | maxLength)
  298|       |                                   base'    length and derived' (minLength | maxLength)
  299|       |
  300|       |     E2-35
  301|       |     It is an error for both length and either of minLength or maxLength to be members of {facets},
  302|       |     unless they are specified in different derivation steps in which case the following must be true:
  303|       |     the {value} of minLength <= the {value} of length <= the {value} of maxLength
  304|       |    ***/
  305|       |
  306|       |    // error: length > base.maxLength
  307|       |    //        length < base.minLength
  308|      4|    if ((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0)
  ------------------
  |  Branch (308:9): [True: 0, False: 4]
  ------------------
  309|      0|    {
  310|      0|        if (((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
  ------------------
  |  Branch (310:13): [True: 0, False: 0]
  ------------------
  311|      0|             (thisLength > baseMaxLength)                                   )
  ------------------
  |  Branch (311:14): [True: 0, False: 0]
  ------------------
  312|      0|        {
  313|      0|            REPORT_FACET_ERROR(thisLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  314|      0|                             , baseMaxLength
  315|      0|                             , XMLExcepts::FACET_Len_baseMaxLen
  316|      0|                             , manager)
  317|      0|        }
  318|       |
  319|      0|        if (((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
  ------------------
  |  Branch (319:13): [True: 0, False: 0]
  ------------------
  320|      0|             (thisLength < baseMinLength)                                   )
  ------------------
  |  Branch (320:14): [True: 0, False: 0]
  ------------------
  321|      0|        {
  322|      0|            REPORT_FACET_ERROR(thisLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  323|      0|                             , baseMinLength
  324|      0|                             , XMLExcepts::FACET_Len_baseMinLen
  325|      0|                             , manager)
  326|      0|        }
  327|      0|    }
  328|       |
  329|       |    // error: baseLength > maxLength
  330|       |    //        baseLength < minLength
  331|      4|    if ((baseFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0)
  ------------------
  |  Branch (331:9): [True: 0, False: 4]
  ------------------
  332|      0|    {
  333|      0|        if (((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
  ------------------
  |  Branch (333:13): [True: 0, False: 0]
  ------------------
  334|      0|             (baseLength > thisMaxLength)                                   )
  ------------------
  |  Branch (334:14): [True: 0, False: 0]
  ------------------
  335|      0|        {
  336|      0|            REPORT_FACET_ERROR(thisMaxLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  337|      0|                             , baseLength
  338|      0|                             , XMLExcepts::FACET_maxLen_baseLen
  339|      0|                             , manager)
  340|      0|        }
  341|       |
  342|      0|        if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
  ------------------
  |  Branch (342:13): [True: 0, False: 0]
  ------------------
  343|      0|             (baseLength < thisMinLength)                                   )
  ------------------
  |  Branch (343:14): [True: 0, False: 0]
  ------------------
  344|      0|        {
  345|      0|            REPORT_FACET_ERROR(thisMinLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  346|      0|                             , baseLength
  347|      0|                             , XMLExcepts::FACET_minLen_baseLen
  348|      0|                             , manager)
  349|      0|        }
  350|      0|    }
  351|       |
  352|       |    // check 4.3.1.c2 error: length != base.length
  353|      4|    if (((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0) &&
  ------------------
  |  Branch (353:9): [True: 0, False: 4]
  ------------------
  354|      4|        ((baseFacetsDefined & DatatypeValidator::FACET_LENGTH) !=0))
  ------------------
  |  Branch (354:9): [True: 0, False: 0]
  ------------------
  355|      0|    {
  356|      0|        if ( thisLength != baseLength )
  ------------------
  |  Branch (356:14): [True: 0, False: 0]
  ------------------
  357|      0|        {
  358|      0|            REPORT_FACET_ERROR(thisLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  359|      0|                             , baseLength
  360|      0|                             , XMLExcepts::FACET_Len_baseLen
  361|      0|                             , manager)
  362|      0|        }
  363|      0|    }
  364|       |
  365|       |    /***
  366|       |                                   |---  derived   ---|
  367|       |                base.minLength <= minLength <= maxLength <= base.maxLength
  368|       |                |-------------------        base      -------------------|
  369|       |    ***/
  370|       |
  371|       |    // check 4.3.2.c1 must: minLength <= base.maxLength
  372|      4|    if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH ) != 0) &&
  ------------------
  |  Branch (372:9): [True: 0, False: 4]
  ------------------
  373|      4|        ((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH ) != 0))
  ------------------
  |  Branch (373:9): [True: 0, False: 0]
  ------------------
  374|      0|    {
  375|      0|        if ( thisMinLength > baseMaxLength )
  ------------------
  |  Branch (375:14): [True: 0, False: 0]
  ------------------
  376|      0|        {
  377|      0|            REPORT_FACET_ERROR(thisMinLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  378|      0|                             , baseMaxLength
  379|      0|                             , XMLExcepts::FACET_minLen_basemaxLen
  380|      0|                             , manager)
  381|      0|        }
  382|      0|    }
  383|       |
  384|       |    // check 4.3.2.c2 error: minLength < base.minLength
  385|      4|    if (((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
  ------------------
  |  Branch (385:9): [True: 0, False: 4]
  ------------------
  386|      4|        ((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) != 0))
  ------------------
  |  Branch (386:9): [True: 0, False: 0]
  ------------------
  387|      0|    {
  388|      0|        if ((baseFixed & DatatypeValidator::FACET_MINLENGTH) !=0)
  ------------------
  |  Branch (388:13): [True: 0, False: 0]
  ------------------
  389|      0|        {
  390|      0|            if ( thisMinLength != baseMinLength )
  ------------------
  |  Branch (390:18): [True: 0, False: 0]
  ------------------
  391|      0|            {
  392|      0|                REPORT_FACET_ERROR(thisMinLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  393|      0|                                 , baseMinLength
  394|      0|                                 , XMLExcepts::FACET_minLen_base_fixed
  395|      0|                                 , manager)
  396|      0|            }
  397|       |
  398|      0|        }
  399|      0|        else
  400|      0|        {
  401|      0|            if ( thisMinLength < baseMinLength )
  ------------------
  |  Branch (401:18): [True: 0, False: 0]
  ------------------
  402|      0|            {
  403|      0|                REPORT_FACET_ERROR(thisMinLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  404|      0|                                 , baseMinLength
  405|      0|                                 , XMLExcepts::FACET_minLen_baseminLen
  406|      0|                                 , manager)
  407|      0|            }
  408|      0|        }
  409|      0|    }
  410|       |
  411|       |    // check 4.3.2.c1 must: base.minLength <= maxLength
  412|      4|    if (((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
  ------------------
  |  Branch (412:9): [True: 0, False: 4]
  ------------------
  413|      4|        ((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0))
  ------------------
  |  Branch (413:9): [True: 0, False: 0]
  ------------------
  414|      0|    {
  415|      0|        if ( baseMinLength > thisMaxLength )
  ------------------
  |  Branch (415:14): [True: 0, False: 0]
  ------------------
  416|      0|        {
  417|      0|            REPORT_FACET_ERROR(thisMaxLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  418|      0|                             , baseMinLength
  419|      0|                             , XMLExcepts::FACET_maxLen_baseminLen
  420|      0|                             , manager)
  421|      0|        }
  422|      0|    }
  423|       |
  424|       |    // check 4.3.3.c1 error: maxLength > base.maxLength
  425|      4|    if (((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
  ------------------
  |  Branch (425:9): [True: 0, False: 4]
  ------------------
  426|      4|        ((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0))
  ------------------
  |  Branch (426:9): [True: 0, False: 0]
  ------------------
  427|      0|    {
  428|      0|        if ((baseFixed & DatatypeValidator::FACET_MAXLENGTH) !=0)
  ------------------
  |  Branch (428:13): [True: 0, False: 0]
  ------------------
  429|      0|        {
  430|      0|            if ( thisMaxLength != baseMaxLength )
  ------------------
  |  Branch (430:18): [True: 0, False: 0]
  ------------------
  431|      0|            {
  432|      0|                REPORT_FACET_ERROR(thisMaxLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  433|      0|                                 , baseMaxLength
  434|      0|                                 , XMLExcepts::FACET_maxLen_base_fixed
  435|      0|                                 , manager)
  436|      0|            }
  437|      0|        }
  438|      0|        else
  439|      0|        {
  440|      0|            if ( thisMaxLength > baseMaxLength )
  ------------------
  |  Branch (440:18): [True: 0, False: 0]
  ------------------
  441|      0|            {
  442|      0|                REPORT_FACET_ERROR(thisMaxLength
  ------------------
  |  |   37|      0|    XMLCh value1[BUF_LEN+1]; \
  |  |   38|      0|    XMLCh value2[BUF_LEN+1]; \
  |  |   39|      0|   XMLString::sizeToText(val1, value1, BUF_LEN, 10, manager);     \
  |  |   40|      0|   XMLString::sizeToText(val2, value2, BUF_LEN, 10, manager);     \
  |  |   41|      0|   ThrowXMLwithMemMgr2(InvalidDatatypeFacetException              \
  |  |  ------------------
  |  |  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  |  |  ------------------
  |  |   42|      0|           , except_code                                \
  |  |   43|      0|           , value1                                     \
  |  |   44|      0|           , value2                                     \
  |  |   45|      0|           , manager);
  ------------------
  443|      0|                                 , baseMaxLength
  444|      0|                                 , XMLExcepts::FACET_maxLen_basemaxLen
  445|      0|                                 , manager)
  446|      0|            }
  447|      0|        }
  448|      0|    }
  449|       |
  450|       |    // check 4.3.5.c0 must: enumeration values from the value space of base
  451|      4|    if ( ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  ------------------
  |  Branch (451:10): [True: 0, False: 4]
  ------------------
  452|      4|        (getEnumeration() !=0))
  ------------------
  |  Branch (452:9): [True: 0, False: 0]
  ------------------
  453|      0|    {
  454|      0|        XMLSize_t i = 0;
  455|      0|        XMLSize_t enumLength = getEnumeration()->size();
  456|      0|        for ( ; i < enumLength; i++)
  ------------------
  |  Branch (456:17): [True: 0, False: 0]
  ------------------
  457|      0|        {
  458|       |            // ask parent do a complete check
  459|      0|            pBaseValidator->checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
  460|       |#if 0
  461|       |// spec says that only base has to checkContent
  462|       |            // enum shall pass this->checkContent() as well.
  463|       |            checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
  464|       |#endif
  465|      0|        }
  466|      0|    }
  467|       |
  468|      4|    checkAdditionalFacetConstraints(manager);
  469|       |
  470|      4|} //end of inspectFacetBase
_ZN11xercesc_3_223AbstractStringValidator12inheritFacetEv:
  478|      9|{
  479|       |    /***
  480|       |        P3. Inherit facets from base.facets
  481|       |
  482|       |        The reason of this inheriting (or copying values) is to ease
  483|       |        schema constraint checking, so that we need NOT trace back to our
  484|       |        very first base validator in the hierachy. Instead, we are pretty
  485|       |        sure checking against immediate base validator is enough.
  486|       |    ***/
  487|       |
  488|      9|    AbstractStringValidator *pBaseValidator = (AbstractStringValidator*) getBaseValidator();
  489|       |
  490|      9|    if (!pBaseValidator)
  ------------------
  |  Branch (490:9): [True: 0, False: 9]
  ------------------
  491|      0|        return;
  492|       |
  493|      9|    int thisFacetsDefined = getFacetsDefined();
  494|      9|    int baseFacetsDefined = pBaseValidator->getFacetsDefined();
  495|       |
  496|       |    // inherit length
  497|      9|    if (((baseFacetsDefined & DatatypeValidator::FACET_LENGTH) != 0) &&
  ------------------
  |  Branch (497:9): [True: 0, False: 9]
  ------------------
  498|      9|        ((thisFacetsDefined & DatatypeValidator::FACET_LENGTH) == 0))
  ------------------
  |  Branch (498:9): [True: 0, False: 0]
  ------------------
  499|      0|    {
  500|      0|        setLength(pBaseValidator->getLength());
  501|      0|        setFacetsDefined(DatatypeValidator::FACET_LENGTH);
  502|      0|    }
  503|       |
  504|       |    // inherit minLength
  505|      9|    if (((baseFacetsDefined & DatatypeValidator::FACET_MINLENGTH) !=0) &&
  ------------------
  |  Branch (505:9): [True: 0, False: 9]
  ------------------
  506|      9|        ((thisFacetsDefined & DatatypeValidator::FACET_MINLENGTH) == 0))
  ------------------
  |  Branch (506:9): [True: 0, False: 0]
  ------------------
  507|      0|    {
  508|      0|        setMinLength(pBaseValidator->getMinLength());
  509|      0|        setFacetsDefined(DatatypeValidator::FACET_MINLENGTH);
  510|      0|    }
  511|       |
  512|       |    // inherit maxLength
  513|      9|    if (((baseFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) !=0) &&
  ------------------
  |  Branch (513:9): [True: 0, False: 9]
  ------------------
  514|      9|        ((thisFacetsDefined & DatatypeValidator::FACET_MAXLENGTH) == 0))
  ------------------
  |  Branch (514:9): [True: 0, False: 0]
  ------------------
  515|      0|    {
  516|      0|        setMaxLength(pBaseValidator->getMaxLength());
  517|      0|        setFacetsDefined(DatatypeValidator::FACET_MAXLENGTH);
  518|      0|    }
  519|       |
  520|       |    // inherit enumeration
  521|      9|    if (((baseFacetsDefined & DatatypeValidator::FACET_ENUMERATION) !=0) &&
  ------------------
  |  Branch (521:9): [True: 0, False: 9]
  ------------------
  522|      9|        ((thisFacetsDefined & DatatypeValidator::FACET_ENUMERATION) == 0))
  ------------------
  |  Branch (522:9): [True: 0, False: 0]
  ------------------
  523|      0|    {
  524|      0|        setEnumeration(pBaseValidator->getEnumeration(), true);
  525|      0|    }
  526|       |
  527|       |    // we don't inherit pattern
  528|       |
  529|       |    // inherit "fixed" option
  530|      9|    setFixed(getFixed() | pBaseValidator->getFixed());
  531|       |
  532|       |    // inherit additional facet
  533|      9|    inheritAdditionalFacet();
  534|       |
  535|      9|} // end of inheritance

_ZNK11xercesc_3_223AbstractStringValidator9getLengthEv:
  192|      8|{
  193|      8|    return fLength;
  194|      8|}
_ZNK11xercesc_3_223AbstractStringValidator12getMaxLengthEv:
  197|     11|{
  198|     11|    return fMaxLength;
  199|     11|}
_ZNK11xercesc_3_223AbstractStringValidator12getMinLengthEv:
  202|     11|{
  203|     11|    return fMinLength;
  204|     11|}
_ZN11xercesc_3_223AbstractStringValidator12setMinLengthEm:
  226|      3|{
  227|      3|    fMinLength = newMinLength;
  228|      3|}

_ZN11xercesc_3_230AnySimpleTypeDatatypeValidatorC2EPNS_13MemoryManagerE:
   36|      1|{
   37|      1|    setWhiteSpace(DatatypeValidator::PRESERVE);
   38|      1|    setFinite(true);
   39|      1|}

_ZN11xercesc_3_223AnyURIDatatypeValidatorC2EPNS_13MemoryManagerE:
   40|      1|{}

_ZN11xercesc_3_229Base64BinaryDatatypeValidatorC2EPNS_13MemoryManagerE:
   37|      1|{}

_ZN11xercesc_3_224BooleanDatatypeValidatorC2EPNS_13MemoryManagerE:
  151|      1|{
  152|      1|    setFinite(true);
  153|      1|}

_ZN11xercesc_3_217DatatypeValidatorC2EPS0_PNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEiNS0_13ValidatorTypeEPNS_13MemoryManagerE:
   99|     45|{
  100|     45|}
_ZN11xercesc_3_217DatatypeValidator11setTypeNameEPKDsS2_:
  124|     25|{
  125|     25|    if (fTypeName) {
  ------------------
  |  Branch (125:9): [True: 0, False: 25]
  ------------------
  126|       |
  127|      0|        fMemoryManager->deallocate(fTypeName);
  128|      0|        fTypeName = 0;
  129|      0|    }
  130|       |
  131|     25|    if (name || uri) {
  ------------------
  |  Branch (131:9): [True: 25, False: 0]
  |  Branch (131:17): [True: 0, False: 0]
  ------------------
  132|       |
  133|     25|        XMLSize_t nameLen = XMLString::stringLen(name);
  134|     25|        XMLSize_t uriLen = XMLString::stringLen(uri);
  135|       |
  136|     25|        fTypeName = (XMLCh*) fMemoryManager->allocate
  137|     25|        (
  138|     25|            (nameLen + uriLen + 2)*sizeof(XMLCh)
  139|     25|        );
  140|     25|        fTypeUri = fTypeName;
  141|     25|        fTypeLocalName = &fTypeName[uriLen+1];
  142|       |
  143|     25|        if (uri)
  ------------------
  |  Branch (143:13): [True: 25, False: 0]
  ------------------
  144|     25|			XMLString::moveChars(fTypeName, uri, uriLen+1);
  145|      0|        else
  146|      0|			fTypeName[0] = chNull;
  147|       |
  148|     25|        if (name)
  ------------------
  |  Branch (148:13): [True: 25, False: 0]
  ------------------
  149|     25|            XMLString::moveChars(&fTypeName[uriLen+1], name, nameLen+1);
  150|      0|        else
  151|      0|            fTypeName[uriLen+1] = chNull;
  152|     25|    }
  153|      0|    else
  154|      0|    {
  155|      0|        fTypeUri = fTypeLocalName = XMLUni::fgZeroLenString;
  156|      0|    }
  157|     25|}
_ZN11xercesc_3_217DatatypeValidator11setTypeNameEPKDs:
  160|     20|{
  161|     20|    if (fTypeName)
  ------------------
  |  Branch (161:9): [True: 0, False: 20]
  ------------------
  162|      0|    {
  163|      0|        fMemoryManager->deallocate(fTypeName);
  164|      0|        fTypeName = 0;
  165|      0|    }
  166|       |
  167|     20|    if (typeName)
  ------------------
  |  Branch (167:9): [True: 20, False: 0]
  ------------------
  168|     20|    {
  169|     20|        XMLSize_t nameLen = XMLString::stringLen(typeName);
  170|     20|        int commaOffset = XMLString::indexOf(typeName, chComma);
  171|       |
  172|     20|        fTypeName = (XMLCh*) fMemoryManager->allocate
  173|     20|        (
  174|     20|            (nameLen + 1) * sizeof(XMLCh)
  175|     20|        );
  176|     20|	    XMLString::moveChars(fTypeName, typeName, nameLen+1);
  177|       |
  178|     20|        if ( commaOffset == -1) {
  ------------------
  |  Branch (178:14): [True: 20, False: 0]
  ------------------
  179|     20|            fTypeUri = SchemaSymbols::fgURI_SCHEMAFORSCHEMA;
  180|     20|            fTypeLocalName = fTypeName;
  181|     20|        }
  182|      0|        else {
  183|      0|            fTypeUri = fTypeName;
  184|      0|            fTypeLocalName = &fTypeName[commaOffset+1];
  185|      0|            fTypeName[commaOffset] = chNull;
  186|      0|        }
  187|     20|    }
  188|      0|    else
  189|      0|    {
  190|      0|        fTypeUri = fTypeLocalName = XMLUni::fgZeroLenString;
  191|      0|    }
  192|     20|}

_ZNK11xercesc_3_217DatatypeValidator9getFacetsEv:
  561|     42|inline RefHashTableOf<KVStringPair>* DatatypeValidator::getFacets() const {
  562|       |
  563|     42|    return fFacets;
  564|     42|}
_ZNK11xercesc_3_217DatatypeValidator16getBaseValidatorEv:
  566|    151|inline DatatypeValidator* DatatypeValidator::getBaseValidator() const {
  567|       |
  568|    151|	return fBaseValidator;
  569|    151|}
_ZNK11xercesc_3_217DatatypeValidator10getWSFacetEv:
  571|     14|inline short DatatypeValidator::getWSFacet() const {
  572|       |
  573|     14|    return fWhiteSpace;
  574|     14|}
_ZNK11xercesc_3_217DatatypeValidator7getTypeEv:
  577|     95|{
  578|     95|    return fType;
  579|     95|}
_ZNK11xercesc_3_217DatatypeValidator16getFacetsDefinedEv:
  582|    272|{
  583|    272|    return fFacetsDefined;
  584|    272|}
_ZNK11xercesc_3_217DatatypeValidator8getFixedEv:
  587|     63|{
  588|     63|    return fFixed;
  589|     63|}
_ZNK11xercesc_3_217DatatypeValidator10getPatternEv:
  592|      3|{
  593|      3|    return fPattern;
  594|      3|}
_ZNK11xercesc_3_217DatatypeValidator8getRegexEv:
  597|     16|{
  598|     16|    return fRegex;
  599|     16|}
_ZNK11xercesc_3_217DatatypeValidator10getOrderedEv:
  627|     17|{
  628|     17|    return fOrdered;
  629|     17|}
_ZNK11xercesc_3_217DatatypeValidator9getFiniteEv:
  632|     17|{
  633|     17|    return fFinite;
  634|     17|}
_ZNK11xercesc_3_217DatatypeValidator10getBoundedEv:
  637|     17|{
  638|     17|    return fBounded;
  639|     17|}
_ZNK11xercesc_3_217DatatypeValidator10getNumericEv:
  642|     17|{
  643|     17|    return fNumeric;
  644|     17|}
_ZN11xercesc_3_217DatatypeValidator13setWhiteSpaceEs:
  655|     20|{
  656|     20|    fWhiteSpace = newValue;
  657|     20|}
_ZN11xercesc_3_217DatatypeValidator16setFacetsDefinedEi:
  660|     48|{
  661|     48|    fFacetsDefined |= facets;
  662|     48|}
_ZN11xercesc_3_217DatatypeValidator8setFixedEi:
  665|     22|{
  666|     22|    fFixed |= fixed;
  667|     22|}
_ZN11xercesc_3_217DatatypeValidator10setPatternEPKDs:
  670|      3|{
  671|      3|    if (fPattern) {
  ------------------
  |  Branch (671:9): [True: 0, False: 3]
  ------------------
  672|      0|        fMemoryManager->deallocate(fPattern);//delete [] fPattern;
  673|      0|        delete fRegex;
  674|      0|    }
  675|      3|    fPattern = XMLString::replicate(pattern, fMemoryManager);
  676|      3|    fRegex = new (fMemoryManager) RegularExpression(fPattern, SchemaSymbols::fgRegEx_XOption, fMemoryManager);
  677|      3|}
_ZN11xercesc_3_217DatatypeValidator10setOrderedENS_22XSSimpleTypeDefinition8ORDERINGE:
  694|     32|{
  695|     32|    fOrdered = ordered;
  696|     32|}
_ZN11xercesc_3_217DatatypeValidator9setFiniteEb:
  699|     24|{
  700|     24|    fFinite = finite;
  701|     24|}
_ZN11xercesc_3_217DatatypeValidator10setBoundedEb:
  704|     22|{
  705|     22|    fBounded = bounded;
  706|     22|}
_ZN11xercesc_3_217DatatypeValidator10setNumericEb:
  709|     23|{
  710|     23|    fNumeric = numeric;
  711|     23|}

_ZN11xercesc_3_214XMLInitializer34initializeDatatypeValidatorFactoryEv:
   91|      1|{
   92|       |    // @@ This is ugly. Need to make expandRegistryToFullSchemaSet
   93|       |    // static.
   94|       |    //
   95|      1|    DatatypeValidatorFactory *dvFactory = new DatatypeValidatorFactory();
   96|      1|    if (dvFactory) {
  ------------------
  |  Branch (96:9): [True: 1, False: 0]
  ------------------
   97|      1|        dvFactory->expandRegistryToFullSchemaSet();
   98|      1|        delete dvFactory;
   99|      1|    }
  100|      1|}
_ZN11xercesc_3_224DatatypeValidatorFactoryC2EPNS_13MemoryManagerE:
  117|      2|{
  118|      2|}
_ZN11xercesc_3_224DatatypeValidatorFactoryD2Ev:
  121|      2|{
  122|      2|    cleanUp();
  123|      2|}
_ZN11xercesc_3_224DatatypeValidatorFactory29expandRegistryToFullSchemaSetEv:
  140|      1|{
  141|       |    //Initialize common Schema/DTD Datatype validator set
  142|      1|    fBuiltInRegistry = new RefHashTableOf<DatatypeValidator>(29);
  143|       |
  144|      1|    DatatypeValidator *dv = new StringDatatypeValidator();
  145|      1|    dv->setTypeName(SchemaSymbols::fgDT_STRING, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  146|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_STRING, dv);
  147|       |
  148|      1|    dv = new NOTATIONDatatypeValidator();
  149|      1|    dv->setTypeName(XMLUni::fgNotationString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  150|      1|    fBuiltInRegistry->put((void*) XMLUni::fgNotationString, dv);
  151|       |
  152|      1|    dv = new AnySimpleTypeDatatypeValidator();
  153|      1|    dv->setTypeName(SchemaSymbols::fgDT_ANYSIMPLETYPE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  154|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYSIMPLETYPE, dv);
  155|       |
  156|      1|    dv = new BooleanDatatypeValidator();
  157|      1|    dv->setTypeName(SchemaSymbols::fgDT_BOOLEAN, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  158|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BOOLEAN, dv);
  159|       |
  160|      1|    dv = new DecimalDatatypeValidator();
  161|      1|    dv->setTypeName(SchemaSymbols::fgDT_DECIMAL, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  162|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DECIMAL, dv);
  163|       |
  164|      1|    dv = new HexBinaryDatatypeValidator();
  165|      1|    dv->setTypeName(SchemaSymbols::fgDT_HEXBINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  166|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_HEXBINARY, dv);
  167|       |
  168|      1|    dv = new Base64BinaryDatatypeValidator();
  169|      1|    dv->setTypeName(SchemaSymbols::fgDT_BASE64BINARY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  170|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_BASE64BINARY, dv);
  171|       |
  172|      1|    dv = new DoubleDatatypeValidator();
  173|      1|    dv->setTypeName(SchemaSymbols::fgDT_DOUBLE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  174|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DOUBLE, dv);
  175|       |
  176|      1|    dv = new FloatDatatypeValidator();
  177|      1|    dv->setTypeName(SchemaSymbols::fgDT_FLOAT, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  178|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_FLOAT, dv);
  179|       |
  180|      1|    dv = new AnyURIDatatypeValidator();
  181|      1|    dv->setTypeName(SchemaSymbols::fgDT_ANYURI, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  182|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_ANYURI, dv);
  183|       |
  184|      1|    dv = new QNameDatatypeValidator();
  185|      1|    dv->setTypeName(SchemaSymbols::fgDT_QNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  186|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_QNAME, dv);
  187|       |
  188|      1|    dv = new DateTimeDatatypeValidator();
  189|      1|    dv->setTypeName(SchemaSymbols::fgDT_DATETIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  190|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATETIME, dv);
  191|       |
  192|      1|    dv = new DateDatatypeValidator();
  193|      1|    dv->setTypeName(SchemaSymbols::fgDT_DATE, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  194|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DATE, dv);
  195|       |
  196|      1|    dv = new TimeDatatypeValidator();
  197|      1|    dv->setTypeName(SchemaSymbols::fgDT_TIME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  198|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_TIME, dv);
  199|       |
  200|      1|    dv = new DayDatatypeValidator();
  201|      1|    dv->setTypeName(SchemaSymbols::fgDT_DAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  202|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DAY, dv);
  203|       |
  204|      1|    dv = new MonthDatatypeValidator();
  205|      1|    dv->setTypeName(SchemaSymbols::fgDT_MONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  206|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTH, dv);
  207|       |
  208|      1|    dv = new MonthDayDatatypeValidator();
  209|      1|    dv->setTypeName(SchemaSymbols::fgDT_MONTHDAY, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  210|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_MONTHDAY, dv);
  211|       |
  212|      1|    dv = new YearDatatypeValidator();
  213|      1|    dv->setTypeName(SchemaSymbols::fgDT_YEAR, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  214|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEAR, dv);
  215|       |
  216|      1|    dv = new YearMonthDatatypeValidator();
  217|      1|    dv->setTypeName(SchemaSymbols::fgDT_YEARMONTH, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  218|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_YEARMONTH, dv);
  219|       |
  220|      1|    dv = new DurationDatatypeValidator();
  221|      1|    dv->setTypeName(SchemaSymbols::fgDT_DURATION, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  222|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_DURATION, dv);
  223|       |
  224|       |    // REVISIT
  225|       |    // We are creating a lot of Hashtables for the facets of the different
  226|       |    // validators. It's better to have some kind of a memory pool and ask
  227|       |    // the pool to give us a new instance of the hashtable.
  228|      1|    RefHashTableOf<KVStringPair>* facets = new RefHashTableOf<KVStringPair>(3);
  229|       |
  230|       |    // Create 'normalizedString' datatype validator
  231|      1|    facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
  232|      1|                new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_REPLACE));
  233|       |
  234|      1|    createDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING,
  235|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_STRING),
  236|      1|                            facets, 0, false, 0, false);
  237|       |
  238|       |    // Create 'token' datatype validator
  239|      1|    facets = new RefHashTableOf<KVStringPair>(3);
  240|      1|    facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
  241|      1|                new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
  242|       |
  243|      1|    createDatatypeValidator(SchemaSymbols::fgDT_TOKEN,
  244|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_NORMALIZEDSTRING),
  245|      1|                            facets, 0, false, 0, false);
  246|       |
  247|       |
  248|      1|    dv = new NameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_TOKEN), 0, 0, 0);
  249|      1|    dv->setTypeName(SchemaSymbols::fgDT_NAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  250|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NAME, dv);
  251|       |
  252|       |
  253|      1|    dv = new NCNameDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NAME), 0, 0, 0);
  254|      1|    dv->setTypeName(SchemaSymbols::fgDT_NCNAME, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  255|      1|    fBuiltInRegistry->put((void*) SchemaSymbols::fgDT_NCNAME, dv);
  256|       |
  257|       |    // Create 'NMTOKEN' datatype validator
  258|      1|    facets = new RefHashTableOf<KVStringPair>(3);
  259|       |
  260|      1|    facets->put((void*) SchemaSymbols::fgELT_PATTERN ,
  261|      1|                new KVStringPair(SchemaSymbols::fgELT_PATTERN,fgTokPattern));
  262|      1|    facets->put((void*) SchemaSymbols::fgELT_WHITESPACE,
  263|      1|                new KVStringPair(SchemaSymbols::fgELT_WHITESPACE, SchemaSymbols::fgWS_COLLAPSE));
  264|       |
  265|      1|    createDatatypeValidator(XMLUni::fgNmTokenString,
  266|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),facets, 0, false, 0, false);
  267|       |
  268|       |    // Create 'NMTOKENS' datatype validator
  269|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  270|      1|    facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
  271|      1|                new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
  272|       |
  273|      1|    createDatatypeValidator(XMLUni::fgNmTokensString,
  274|      1|                            getDatatypeValidator(XMLUni::fgNmTokenString), facets, 0, true, 0, false);
  275|       |
  276|       |    // Create 'language' datatype validator
  277|      1|    facets = new RefHashTableOf<KVStringPair>(3);
  278|       |
  279|      1|    facets->put((void*) SchemaSymbols::fgELT_PATTERN,
  280|      1|                new KVStringPair(SchemaSymbols::fgELT_PATTERN, XMLUni::fgLangPattern));
  281|       |
  282|      1|    createDatatypeValidator(SchemaSymbols::fgDT_LANGUAGE,
  283|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_TOKEN),
  284|      1|                            facets, 0, false, 0, false);
  285|       |
  286|       |    // Create 'integer' datatype validator
  287|      1|    facets = new RefHashTableOf<KVStringPair>(3);
  288|       |
  289|      1|    facets->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS,
  290|      1|                new KVStringPair(SchemaSymbols::fgELT_FRACTIONDIGITS, XMLUni::fgValueZero));
  291|       |
  292|      1|    facets->put((void*) SchemaSymbols::fgELT_PATTERN,
  293|      1|                new KVStringPair(SchemaSymbols::fgELT_PATTERN, fgIntegerPattern));
  294|       |
  295|      1|    createDatatypeValidator(SchemaSymbols::fgDT_INTEGER,
  296|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
  297|      1|                            facets, 0, false, 0, false);
  298|       |
  299|       |    // Create 'nonPositiveInteger' datatype validator
  300|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  301|       |
  302|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  303|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgValueZero));
  304|       |
  305|      1|    createDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER,
  306|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
  307|      1|                            facets, 0, false, 0, false);
  308|       |
  309|       |    // Create 'negativeInteger' datatype validator
  310|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  311|       |
  312|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  313|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgNegOne));
  314|       |
  315|      1|    createDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER,
  316|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
  317|      1|                            facets, 0, false, 0, false);
  318|       |
  319|       |    // Create 'long' datatype validator
  320|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  321|       |
  322|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  323|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgLongMaxInc));
  324|      1|    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
  325|      1|                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgLongMinInc));
  326|       |
  327|      1|    createDatatypeValidator(SchemaSymbols::fgDT_LONG,
  328|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
  329|      1|                            facets, 0, false, 0, false);
  330|       |
  331|       |    // Create 'int' datatype validator
  332|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  333|       |
  334|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  335|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgIntMaxInc));
  336|      1|    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
  337|      1|                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgIntMinInc));
  338|       |
  339|      1|    createDatatypeValidator(SchemaSymbols::fgDT_INT,
  340|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_LONG),
  341|      1|                            facets, 0, false, 0, false);
  342|       |
  343|       |    // Create 'short' datatype validator
  344|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  345|       |
  346|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  347|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgShortMaxInc));
  348|      1|    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
  349|      1|                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgShortMinInc));
  350|       |
  351|      1|    createDatatypeValidator(SchemaSymbols::fgDT_SHORT,
  352|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_INT),
  353|      1|                            facets, 0, false, 0 ,false);
  354|       |
  355|       |    // Create 'byte' datatype validator
  356|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  357|       |
  358|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  359|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgByteMaxInc));
  360|      1|    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
  361|      1|                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgByteMinInc));
  362|       |
  363|      1|    createDatatypeValidator(SchemaSymbols::fgDT_BYTE,
  364|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
  365|      1|                            facets, 0, false, 0, false);
  366|       |
  367|       |    // Create 'nonNegativeInteger' datatype validator
  368|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  369|       |
  370|      1|    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
  371|      1|                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueZero));
  372|       |
  373|      1|    createDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER,
  374|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
  375|      1|                            facets, 0, false, 0, false);
  376|       |
  377|       |    // Create 'unsignedLong' datatype validator
  378|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  379|       |
  380|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  381|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgULongMaxInc));
  382|       |
  383|      1|    createDatatypeValidator(SchemaSymbols::fgDT_ULONG,
  384|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
  385|      1|                            facets, 0, false, 0, false);
  386|       |
  387|       |    // Create 'unsignedInt' datatype validator
  388|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  389|       |
  390|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  391|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUIntMaxInc));
  392|       |
  393|      1|    createDatatypeValidator(SchemaSymbols::fgDT_UINT,
  394|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
  395|      1|                            facets, 0, false, 0, false);
  396|       |
  397|       |    // Create 'unsignedShort' datatypeValidator
  398|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  399|       |
  400|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  401|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUShortMaxInc));
  402|       |
  403|      1|    createDatatypeValidator(SchemaSymbols::fgDT_USHORT,
  404|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_UINT),
  405|      1|                            facets, 0, false, 0, false);
  406|       |
  407|       |    // Create 'unsignedByte' datatype validator
  408|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  409|       |
  410|      1|    facets->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE,
  411|      1|                new KVStringPair(SchemaSymbols::fgELT_MAXINCLUSIVE, XMLUni::fgUByteMaxInc));
  412|       |
  413|      1|    createDatatypeValidator(SchemaSymbols::fgDT_UBYTE,
  414|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
  415|      1|                            facets, 0, false, 0, false);
  416|       |
  417|       |    // Create 'positiveInteger' datatype validator
  418|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  419|       |
  420|      1|    facets->put((void*) SchemaSymbols::fgELT_MININCLUSIVE,
  421|      1|                new KVStringPair(SchemaSymbols::fgELT_MININCLUSIVE, XMLUni::fgValueOne));
  422|       |
  423|      1|    createDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER,
  424|      1|                            getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
  425|      1|                            facets, 0, false, 0, false);
  426|       |
  427|       |    // Create 'ID', 'IDREF' and 'ENTITY' datatype validator
  428|      1|    dv = new IDDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
  429|      1|    dv->setTypeName(XMLUni::fgIDString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  430|      1|    fBuiltInRegistry->put((void*) XMLUni::fgIDString, dv);
  431|       |
  432|      1|    dv = new IDREFDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
  433|      1|    dv->setTypeName(XMLUni::fgIDRefString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  434|      1|    fBuiltInRegistry->put((void*) XMLUni::fgIDRefString, dv);
  435|       |
  436|      1|    dv = new ENTITYDatatypeValidator(getDatatypeValidator(SchemaSymbols::fgDT_NCNAME), 0, 0, 0);
  437|      1|    dv->setTypeName(XMLUni::fgEntityString, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
  438|      1|    fBuiltInRegistry->put((void*) XMLUni::fgEntityString, dv);
  439|       |
  440|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  441|      1|    facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
  442|      1|                new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
  443|       |
  444|       |    // Create 'IDREFS' datatype validator
  445|      1|    createDatatypeValidator
  446|      1|      (
  447|      1|        XMLUni::fgIDRefsString
  448|      1|        , getDatatypeValidator(XMLUni::fgIDRefString)
  449|      1|        , facets
  450|      1|        , 0
  451|      1|        , true
  452|      1|        , 0
  453|      1|        , false
  454|      1|      );
  455|       |
  456|      1|    facets = new RefHashTableOf<KVStringPair>(2);
  457|       |
  458|      1|    facets->put((void*) SchemaSymbols::fgELT_MINLENGTH,
  459|      1|                new KVStringPair(SchemaSymbols::fgELT_MINLENGTH, XMLUni::fgValueOne));
  460|       |
  461|       |    // Create 'ENTITIES' datatype validator
  462|      1|    createDatatypeValidator
  463|      1|      (
  464|      1|        XMLUni::fgEntitiesString
  465|      1|        , getDatatypeValidator(XMLUni::fgEntityString)
  466|      1|        , facets
  467|      1|        , 0
  468|      1|        , true
  469|      1|        , 0
  470|      1|        , false
  471|      1|      );
  472|       |
  473|      1|    initCanRepRegistory();
  474|      1|}
_ZN11xercesc_3_224DatatypeValidatorFactory19initCanRepRegistoryEv:
  491|      1|{
  492|       |
  493|       |     /***
  494|       |      * key:  dv
  495|       |      * data: XMLCanRepGroup
  496|       |      ***/
  497|      1|     fCanRepRegistry  = new RefHashTableOf<XMLCanRepGroup, PtrHasher>(29, true);
  498|       |
  499|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_DECIMAL),
  500|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal));
  501|       |
  502|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_INTEGER),
  503|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  504|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_LONG),
  505|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  506|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_INT),
  507|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  508|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_SHORT),
  509|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  510|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_BYTE),
  511|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  512|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER),
  513|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  514|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_POSITIVEINTEGER),
  515|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_signed));
  516|       |
  517|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_NEGATIVEINTEGER),
  518|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
  519|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_ULONG),
  520|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
  521|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_UINT),
  522|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
  523|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_USHORT),
  524|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
  525|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_UBYTE),
  526|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_unsigned));
  527|       |
  528|      1|     fCanRepRegistry->put((void*) getDatatypeValidator(SchemaSymbols::fgDT_NONPOSITIVEINTEGER),
  529|      1|                        new  XMLCanRepGroup(XMLCanRepGroup::Decimal_Derived_npi));
  530|      1|}
_ZN11xercesc_3_224DatatypeValidatorFactory23createDatatypeValidatorEPKDsPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEbibPNS_13MemoryManagerE:
  586|     20|{
  587|     20|	if (baseValidator == 0) {
  ------------------
  |  Branch (587:6): [True: 0, False: 20]
  ------------------
  588|       |
  589|      0|        if (facets) {
  ------------------
  |  Branch (589:13): [True: 0, False: 0]
  ------------------
  590|      0|            Janitor<KVStringPairHashTable> janFacets(facets);
  591|      0|        }
  592|       |
  593|      0|        if (enums) {
  ------------------
  |  Branch (593:13): [True: 0, False: 0]
  ------------------
  594|      0|            Janitor<XMLChRefVector> janEnums(enums);
  595|      0|        }
  596|       |
  597|      0|        return 0;
  598|      0|    }
  599|       |
  600|     20|	DatatypeValidator* datatypeValidator = 0;
  601|     20|    MemoryManager* const manager = (isUserDefined)
  ------------------
  |  Branch (601:36): [True: 0, False: 20]
  ------------------
  602|     20|        ? userManager : XMLPlatformUtils::fgMemoryManager;
  603|       |
  604|     20|    if (isDerivedByList) {
  ------------------
  |  Branch (604:9): [True: 3, False: 17]
  ------------------
  605|      3|        datatypeValidator = new (manager) ListDatatypeValidator(baseValidator, facets, enums, finalSet, manager);
  606|       |
  607|       |        // Set PSVI information for Ordered, Numeric, Bounded & Finite
  608|      3|        datatypeValidator->setOrdered(XSSimpleTypeDefinition::ORDERED_FALSE);
  609|      3|        datatypeValidator->setNumeric(false);
  610|      3|        if (facets &&
  ------------------
  |  Branch (610:13): [True: 3, False: 0]
  ------------------
  611|      3|             ((facets->get(SchemaSymbols::fgELT_LENGTH) ||
  ------------------
  |  Branch (611:16): [True: 0, False: 3]
  ------------------
  612|      3|              (facets->get(SchemaSymbols::fgELT_MINLENGTH) && facets->get(SchemaSymbols::fgELT_MAXLENGTH)))))
  ------------------
  |  Branch (612:16): [True: 3, False: 0]
  |  Branch (612:63): [True: 0, False: 3]
  ------------------
  613|      0|        {
  614|      0|            datatypeValidator->setBounded(true);
  615|      0|            datatypeValidator->setFinite(true);
  616|      0|        }
  617|      3|        else
  618|      3|        {
  619|      3|            datatypeValidator->setBounded(false);
  620|      3|            datatypeValidator->setFinite(false);
  621|      3|        }
  622|      3|    }
  623|     17|    else {
  624|       |
  625|     17|        if ((baseValidator->getType() != DatatypeValidator::String) && facets) {
  ------------------
  |  Branch (625:13): [True: 13, False: 4]
  |  Branch (625:72): [True: 13, False: 0]
  ------------------
  626|       |
  627|     13|            KVStringPair* value = facets->get(SchemaSymbols::fgELT_WHITESPACE);
  628|       |
  629|     13|            if (value != 0) {
  ------------------
  |  Branch (629:17): [True: 0, False: 13]
  ------------------
  630|      0|                facets->removeKey(SchemaSymbols::fgELT_WHITESPACE);
  631|      0|            }
  632|     13|        }
  633|       |
  634|     17|        datatypeValidator = baseValidator->newInstance
  635|     17|        (
  636|     17|            facets
  637|     17|            , enums
  638|     17|            , finalSet
  639|     17|            , manager
  640|     17|        );
  641|       |
  642|       |        // Set PSVI information for Ordered, Numeric, Bounded & Finite
  643|     17|        datatypeValidator->setOrdered(baseValidator->getOrdered());
  644|     17|        datatypeValidator->setNumeric(baseValidator->getNumeric());
  645|     17|        RefHashTableOf<KVStringPair>* baseFacets = baseValidator->getFacets();
  646|     17|        if (facets  &&
  ------------------
  |  Branch (646:13): [True: 17, False: 0]
  ------------------
  647|     17|            ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
  ------------------
  |  Branch (647:15): [True: 6, False: 11]
  ------------------
  648|     17|              facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE) ||
  ------------------
  |  Branch (648:15): [True: 0, False: 11]
  ------------------
  649|     17|              (baseFacets && (baseFacets->get(SchemaSymbols::fgELT_MININCLUSIVE) ||
  ------------------
  |  Branch (649:16): [True: 9, False: 2]
  |  Branch (649:31): [True: 1, False: 8]
  ------------------
  650|      9|                              baseFacets->get(SchemaSymbols::fgELT_MINEXCLUSIVE))))) &&
  ------------------
  |  Branch (650:31): [True: 0, False: 8]
  ------------------
  651|     17|             (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
  ------------------
  |  Branch (651:15): [True: 5, False: 2]
  ------------------
  652|      7|              facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE) ||
  ------------------
  |  Branch (652:15): [True: 0, False: 2]
  ------------------
  653|      7|              (baseFacets && ((baseFacets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) ||
  ------------------
  |  Branch (653:16): [True: 2, False: 0]
  |  Branch (653:32): [True: 0, False: 2]
  ------------------
  654|      2|                               baseFacets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE))))))
  ------------------
  |  Branch (654:32): [True: 0, False: 2]
  ------------------
  655|      5|        {
  656|      5|            datatypeValidator->setBounded(true);
  657|      5|        }
  658|     12|        else
  659|     12|        {
  660|     12|            datatypeValidator->setBounded(false);
  661|     12|        }
  662|     17|        if (baseValidator->getFinite())
  ------------------
  |  Branch (662:13): [True: 0, False: 17]
  ------------------
  663|      0|        {
  664|      0|            datatypeValidator->setFinite(true);
  665|      0|        }
  666|     17|        else if (!facets)
  ------------------
  |  Branch (666:18): [True: 0, False: 17]
  ------------------
  667|      0|        {
  668|      0|            datatypeValidator->setFinite(false);
  669|      0|        }
  670|     17|        else if (facets->get(SchemaSymbols::fgELT_LENGTH) || facets->get(SchemaSymbols::fgELT_MAXLENGTH) ||
  ------------------
  |  Branch (670:18): [True: 0, False: 17]
  |  Branch (670:62): [True: 0, False: 17]
  ------------------
  671|     17|                 facets->get(SchemaSymbols::fgELT_TOTALDIGITS))
  ------------------
  |  Branch (671:18): [True: 0, False: 17]
  ------------------
  672|      0|        {
  673|      0|            datatypeValidator->setFinite(true);
  674|      0|        }
  675|       |        //for efficiency use this instead of rechecking...
  676|       |        //else if ((facets->get(SchemaSymbols::fgELT_MININCLUSIVE) || facets->get(SchemaSymbols::fgELT_MINEXCLUSIVE)) &&
  677|       |        //         (facets->get(SchemaSymbols::fgELT_MAXINCLUSIVE) || facets->get(SchemaSymbols::fgELT_MAXEXCLUSIVE)))
  678|     17|        else if (datatypeValidator->getBounded() ||
  ------------------
  |  Branch (678:18): [True: 5, False: 12]
  ------------------
  679|     17|                 datatypeValidator->getType() == DatatypeValidator::Date      ||
  ------------------
  |  Branch (679:18): [True: 0, False: 12]
  ------------------
  680|     17|                 datatypeValidator->getType() == DatatypeValidator::YearMonth ||
  ------------------
  |  Branch (680:18): [True: 0, False: 12]
  ------------------
  681|     17|                 datatypeValidator->getType() == DatatypeValidator::Year      ||
  ------------------
  |  Branch (681:18): [True: 0, False: 12]
  ------------------
  682|     17|                 datatypeValidator->getType() == DatatypeValidator::MonthDay  ||
  ------------------
  |  Branch (682:18): [True: 0, False: 12]
  ------------------
  683|     17|                 datatypeValidator->getType() == DatatypeValidator::Day       ||
  ------------------
  |  Branch (683:18): [True: 0, False: 12]
  ------------------
  684|     17|                 datatypeValidator->getType() == DatatypeValidator::Month)
  ------------------
  |  Branch (684:18): [True: 0, False: 12]
  ------------------
  685|      5|        {
  686|      5|            if (facets->get(SchemaSymbols::fgELT_FRACTIONDIGITS))
  ------------------
  |  Branch (686:17): [True: 0, False: 5]
  ------------------
  687|      0|            {
  688|      0|                datatypeValidator->setFinite(true);
  689|      0|            }
  690|      5|            else
  691|      5|            {
  692|      5|                datatypeValidator->setFinite(false);
  693|      5|            }
  694|      5|        }
  695|     12|        else
  696|     12|        {
  697|     12|            datatypeValidator->setFinite(false);
  698|     12|        }
  699|     17|    }
  700|       |
  701|     20|    if (datatypeValidator != 0) {
  ------------------
  |  Branch (701:9): [True: 20, False: 0]
  ------------------
  702|       |
  703|     20|        if (isUserDefined) {
  ------------------
  |  Branch (703:13): [True: 0, False: 20]
  ------------------
  704|       |
  705|      0|            if (!fUserDefinedRegistry) {
  ------------------
  |  Branch (705:17): [True: 0, False: 0]
  ------------------
  706|      0|                fUserDefinedRegistry = new (userManager) RefHashTableOf<DatatypeValidator>(29, userManager);
  707|      0|            }
  708|       |
  709|      0|            fUserDefinedRegistry->put((void *)typeName, datatypeValidator);
  710|      0|        }
  711|     20|        else {
  712|     20|            fBuiltInRegistry->put((void *)typeName, datatypeValidator);
  713|     20|        }
  714|       |
  715|     20|        datatypeValidator->setTypeName(typeName);
  716|     20|    }
  717|       |
  718|     20|    return datatypeValidator;
  719|     20|}

_ZNK11xercesc_3_224DatatypeValidatorFactory20getDatatypeValidatorEPKDs:
  244|     42|{
  245|     42|	if (dvType) {
  ------------------
  |  Branch (245:6): [True: 42, False: 0]
  ------------------
  246|     42|        if (fBuiltInRegistry && fBuiltInRegistry->containsKey(dvType)) {
  ------------------
  |  Branch (246:13): [True: 42, False: 0]
  |  Branch (246:33): [True: 42, False: 0]
  ------------------
  247|     42|		    return fBuiltInRegistry->get(dvType);
  248|     42|        }
  249|       |
  250|      0|        if (fUserDefinedRegistry && fUserDefinedRegistry->containsKey(dvType)) {
  ------------------
  |  Branch (250:13): [True: 0, False: 0]
  |  Branch (250:37): [True: 0, False: 0]
  ------------------
  251|      0|		    return fUserDefinedRegistry->get(dvType);
  252|       |
  253|      0|        }
  254|      0|    }
  255|      0|	return 0;
  256|     42|}
_ZN11xercesc_3_224DatatypeValidatorFactory7cleanUpEv:
  270|      2|inline void DatatypeValidatorFactory::cleanUp() {
  271|       |
  272|      2|    if (fUserDefinedRegistry)
  ------------------
  |  Branch (272:9): [True: 0, False: 2]
  ------------------
  273|      0|    {
  274|      0|	    delete fUserDefinedRegistry;
  275|      0|	    fUserDefinedRegistry = 0;
  276|      0|    }
  277|      2|}

_ZN11xercesc_3_221DateDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_225DateTimeDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_217DateTimeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEiNS1_13ValidatorTypeEPNS_13MemoryManagerE:
   57|      9|{
   58|       |    //do not invoke init() here !!!
   59|      9|}

_ZN11xercesc_3_220DayDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_224DecimalDatatypeValidatorC2EPNS_13MemoryManagerE:
   47|      1|{
   48|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_TOTAL);
   49|      1|    setNumeric(true);
   50|      1|}
_ZN11xercesc_3_224DecimalDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   61|     13|{
   62|     13|    init(enums, manager);
   63|     13|}
_ZN11xercesc_3_224DecimalDatatypeValidator11newInstanceEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   89|     13|{
   90|     13|    return (DatatypeValidator*) new (manager) DecimalDatatypeValidator(this, facets, enums, finalSet, manager);
   91|     13|}
_ZN11xercesc_3_224DecimalDatatypeValidator21assignAdditionalFacetEPKDsS2_PNS_13MemoryManagerE:
  111|      1|{
  112|      1|    if (XMLString::equals(key, SchemaSymbols::fgELT_TOTALDIGITS))
  ------------------
  |  Branch (112:9): [True: 0, False: 1]
  ------------------
  113|      0|    {
  114|      0|        int val;
  115|      0|        try
  116|      0|        {
  117|      0|            val = XMLString::parseInt(value, manager);
  118|      0|        }
  119|      0|        catch (NumberFormatException&)
  120|      0|        {
  121|      0|            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_TotalDigit, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  122|      0|        }
  123|       |
  124|       |        // check 4.3.11.c0 must: totalDigits > 0
  125|      0|        if ( val <= 0 )
  ------------------
  |  Branch (125:14): [True: 0, False: 0]
  ------------------
  126|      0|            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_PosInt_TotalDigit, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  127|       |
  128|      0|        setTotalDigits(val);
  129|      0|        setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
  130|      0|    }
  131|      1|    else if (XMLString::equals(key, SchemaSymbols::fgELT_FRACTIONDIGITS))
  ------------------
  |  Branch (131:14): [True: 1, False: 0]
  ------------------
  132|      1|    {
  133|      1|        int val;
  134|      1|        try
  135|      1|        {
  136|      1|            val = XMLString::parseInt(value, manager);
  137|      1|        }
  138|      1|        catch (NumberFormatException&)
  139|      1|        {
  140|      0|            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_FractDigit, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  141|      0|        }
  142|       |
  143|       |        // check 4.3.12.c0 must: fractionDigits > 0
  144|      1|        if ( val < 0 )
  ------------------
  |  Branch (144:14): [True: 0, False: 1]
  ------------------
  145|      0|            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_NonNeg_FractDigit, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  146|       |
  147|      1|        setFractionDigits(val);
  148|      1|        setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
  149|      1|    }
  150|      0|    else
  151|      0|    {
  152|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  153|      0|                , XMLExcepts::FACET_Invalid_Tag
  154|      0|                , key
  155|      0|                , manager);
  156|      0|    }
  157|      1|}
_ZN11xercesc_3_224DecimalDatatypeValidator22inheritAdditionalFacetEv:
  160|     13|{
  161|       |
  162|     13|    DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
  163|       |
  164|     13|    if (!numBase)
  ------------------
  |  Branch (164:9): [True: 0, False: 13]
  ------------------
  165|      0|        return;
  166|       |
  167|     13|    int thisFacetsDefined = getFacetsDefined();
  168|     13|    int baseFacetsDefined = numBase->getFacetsDefined();
  169|       |
  170|       |    // inherit totalDigits
  171|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  ------------------
  |  Branch (171:9): [True: 0, False: 13]
  ------------------
  172|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) == 0) )
  ------------------
  |  Branch (172:9): [True: 0, False: 0]
  ------------------
  173|      0|    {
  174|      0|        setTotalDigits(numBase->fTotalDigits);
  175|      0|        setFacetsDefined(DatatypeValidator::FACET_TOTALDIGITS);
  176|      0|    }
  177|       |
  178|       |    // inherit fractionDigits
  179|     13|    if ((( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  ------------------
  |  Branch (179:9): [True: 12, False: 1]
  ------------------
  180|     13|        (( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) == 0) )
  ------------------
  |  Branch (180:9): [True: 12, False: 0]
  ------------------
  181|     12|    {
  182|     12|        setFractionDigits(numBase->fFractionDigits);
  183|     12|        setFacetsDefined(DatatypeValidator::FACET_FRACTIONDIGITS);
  184|     12|    }
  185|     13|}
_ZNK11xercesc_3_224DecimalDatatypeValidator31checkAdditionalFacetConstraintsEPNS_13MemoryManagerE:
  188|     13|{
  189|     13|    int thisFacetsDefined = getFacetsDefined();
  190|       |
  191|       |    // check 4.3.12.c1 must: fractionDigits <= totalDigits
  192|     13|    if ( ((thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  ------------------
  |  Branch (192:10): [True: 1, False: 12]
  ------------------
  193|     13|         ((thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) )
  ------------------
  |  Branch (193:10): [True: 0, False: 1]
  ------------------
  194|      0|    {
  195|      0|        if ( fFractionDigits > fTotalDigits )
  ------------------
  |  Branch (195:14): [True: 0, False: 0]
  ------------------
  196|      0|        {
  197|      0|            XMLCh value1[BUF_LEN+1];
  198|      0|            XMLCh value2[BUF_LEN+1];
  199|      0|            XMLString::binToText(getFractionDigits(), value1, BUF_LEN, 10, manager);
  200|      0|            XMLString::binToText(getTotalDigits(), value2, BUF_LEN, 10, manager);
  201|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  202|      0|                                 , XMLExcepts::FACET_TotDigit_FractDigit
  203|      0|                                 , value2
  204|      0|                                 , value1
  205|      0|                                 , manager);
  206|      0|        }
  207|      0|    }
  208|       |
  209|     13|}
_ZNK11xercesc_3_224DecimalDatatypeValidator35checkAdditionalFacetConstraintsBaseEPNS_13MemoryManagerE:
  212|     13|{
  213|       |
  214|     13|    DecimalDatatypeValidator *numBase = (DecimalDatatypeValidator*) getBaseValidator();
  215|       |
  216|     13|    if (!numBase)
  ------------------
  |  Branch (216:9): [True: 0, False: 13]
  ------------------
  217|      0|        return;
  218|       |
  219|     13|    int thisFacetsDefined = getFacetsDefined();
  220|     13|    int baseFacetsDefined = numBase->getFacetsDefined();
  221|       |
  222|       |    // check 4.3.11.c1 error: totalDigits > base.totalDigits
  223|       |    // totalDigits != base.totalDigits if (base.fixed)
  224|     13|    if (( thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0)
  ------------------
  |  Branch (224:9): [True: 0, False: 13]
  ------------------
  225|      0|    {
  226|      0|        if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  ------------------
  |  Branch (226:14): [True: 0, False: 0]
  ------------------
  227|      0|            ( fTotalDigits > numBase->fTotalDigits ))
  ------------------
  |  Branch (227:13): [True: 0, False: 0]
  ------------------
  228|      0|        {
  229|      0|            XMLCh value1[BUF_LEN+1];
  230|      0|            XMLCh value2[BUF_LEN+1];
  231|      0|            XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10, manager);
  232|      0|            XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10, manager);
  233|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  234|      0|                                 , XMLExcepts::FACET_totalDigit_base_totalDigit
  235|      0|                                 , value1
  236|      0|                                 , value2
  237|      0|                                 , manager);
  238|      0|        }
  239|       |
  240|      0|        if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  ------------------
  |  Branch (240:14): [True: 0, False: 0]
  ------------------
  241|      0|            (( numBase->getFixed() & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  ------------------
  |  Branch (241:13): [True: 0, False: 0]
  ------------------
  242|      0|            ( fTotalDigits != numBase->fTotalDigits ))
  ------------------
  |  Branch (242:13): [True: 0, False: 0]
  ------------------
  243|      0|        {
  244|      0|            XMLCh value1[BUF_LEN+1];
  245|      0|            XMLCh value2[BUF_LEN+1];
  246|      0|            XMLString::binToText(fTotalDigits, value1, BUF_LEN, 10, manager);
  247|      0|            XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10, manager);
  248|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  249|      0|                                 , XMLExcepts::FACET_totalDigit_base_fixed
  250|      0|                                 , value1
  251|      0|                                 , value2
  252|      0|                                 , manager);
  253|      0|        }
  254|      0|    }
  255|       |
  256|     13|    if (( thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0)
  ------------------
  |  Branch (256:9): [True: 1, False: 12]
  ------------------
  257|      1|    {
  258|       |        // check question error: fractionDigits > base.fractionDigits ???
  259|      1|        if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  ------------------
  |  Branch (259:14): [True: 0, False: 1]
  ------------------
  260|      1|            ( fFractionDigits > numBase->fFractionDigits ))
  ------------------
  |  Branch (260:13): [True: 0, False: 0]
  ------------------
  261|      0|        {
  262|      0|            XMLCh value1[BUF_LEN+1];
  263|      0|            XMLCh value2[BUF_LEN+1];
  264|      0|            XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10, manager);
  265|      0|            XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10, manager);
  266|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  267|      0|                                 , XMLExcepts::FACET_fractDigit_base_fractDigit
  268|      0|                                 , value1
  269|      0|                                 , value2
  270|      0|                                 , manager);
  271|      0|                        }
  272|       |
  273|       |        // check question error: fractionDigits > base.totalDigits ???
  274|      1|        if ( (( baseFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0) &&
  ------------------
  |  Branch (274:14): [True: 0, False: 1]
  ------------------
  275|      1|            ( fFractionDigits > numBase->fTotalDigits ))
  ------------------
  |  Branch (275:13): [True: 0, False: 0]
  ------------------
  276|      0|        {
  277|      0|            XMLCh value1[BUF_LEN+1];
  278|      0|            XMLCh value2[BUF_LEN+1];
  279|      0|            XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10, manager);
  280|      0|            XMLString::binToText(numBase->fTotalDigits, value2, BUF_LEN, 10, manager);
  281|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  282|      0|                                 , XMLExcepts::FACET_fractDigit_base_totalDigit
  283|      0|                                 , value1
  284|      0|                                 , value2
  285|      0|                                 , manager);
  286|      0|        }
  287|       |
  288|       |        // fractionDigits != base.fractionDigits if (base.fixed)
  289|      1|        if ( (( baseFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  ------------------
  |  Branch (289:14): [True: 0, False: 1]
  ------------------
  290|      1|            (( numBase->getFixed() & DatatypeValidator::FACET_FRACTIONDIGITS) != 0) &&
  ------------------
  |  Branch (290:13): [True: 0, False: 0]
  ------------------
  291|      1|            ( fFractionDigits != numBase->fFractionDigits ))
  ------------------
  |  Branch (291:13): [True: 0, False: 0]
  ------------------
  292|      0|        {
  293|      0|            XMLCh value1[BUF_LEN+1];
  294|      0|            XMLCh value2[BUF_LEN+1];
  295|      0|            XMLString::binToText(fFractionDigits, value1, BUF_LEN, 10, manager);
  296|      0|            XMLString::binToText(numBase->fFractionDigits, value2, BUF_LEN, 10, manager);
  297|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  298|      0|                                 , XMLExcepts::FACET_fractDigit_base_fixed
  299|      0|                                 , value1
  300|      0|                                 , value2
  301|      0|                                 , manager);
  302|      0|        }
  303|      1|    }
  304|       |
  305|     13|}
_ZN11xercesc_3_224DecimalDatatypeValidator13compareValuesEPKNS_9XMLNumberES3_:
  309|     46|{
  310|     46|    return XMLBigDecimal::compareValues((XMLBigDecimal*) lValue, (XMLBigDecimal*) rValue,
  311|     46|                                        ((XMLBigDecimal*)lValue)->getMemoryManager());
  312|     46|}
_ZN11xercesc_3_224DecimalDatatypeValidator15setMaxInclusiveEPKDs:
  315|     10|{
  316|     10|    fMaxInclusive = new (fMemoryManager) XMLBigDecimal(value, fMemoryManager);
  317|     10|}
_ZN11xercesc_3_224DecimalDatatypeValidator15setMinInclusiveEPKDs:
  325|      6|{
  326|      6|    fMinInclusive = new (fMemoryManager) XMLBigDecimal(value, fMemoryManager);
  327|      6|}
_ZN11xercesc_3_224DecimalDatatypeValidator12checkContentEPKDsPNS_17ValidationContextEbPNS_13MemoryManagerE:
  392|     56|{
  393|       |    //validate against base validator if any
  394|     56|    DecimalDatatypeValidator *pBase = (DecimalDatatypeValidator*) this->getBaseValidator();
  395|     56|    if (pBase)
  ------------------
  |  Branch (395:9): [True: 40, False: 16]
  ------------------
  396|     40|        pBase->checkContent(content, context, true, manager);
  397|       |
  398|     56|    int thisFacetsDefined = getFacetsDefined();
  399|       |
  400|       |    // we check pattern first
  401|     56|    if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
  ------------------
  |  Branch (401:10): [True: 16, False: 40]
  ------------------
  402|     16|    {
  403|     16|        if (getRegex()->matches(content, manager) ==false)
  ------------------
  |  Branch (403:13): [True: 0, False: 16]
  ------------------
  404|      0|        {
  405|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeValueException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  406|      0|                    , XMLExcepts::VALUE_NotMatch_Pattern
  407|      0|                    , content
  408|      0|                    , getPattern()
  409|      0|                    , manager);
  410|      0|        }
  411|     16|    }
  412|       |
  413|       |    // if this is a base validator, we only need to check pattern facet
  414|       |    // all other facet were inherited by the derived type
  415|     56|    if (asBase)
  ------------------
  |  Branch (415:9): [True: 40, False: 16]
  ------------------
  416|     40|        return;
  417|       |
  418|     16|    XMLBigDecimal  compareDataValue(content, manager);
  419|     16|    XMLBigDecimal* compareData = &compareDataValue;
  420|       |
  421|     16|    if (getEnumeration())
  ------------------
  |  Branch (421:9): [True: 0, False: 16]
  ------------------
  422|      0|    {
  423|      0|        XMLSize_t i=0;
  424|      0|        XMLSize_t enumLength = getEnumeration()->size();
  425|      0|        for ( ; i < enumLength; i++)
  ------------------
  |  Branch (425:17): [True: 0, False: 0]
  ------------------
  426|      0|        {
  427|      0|            if (compareValues(compareData, (XMLBigDecimal*) getEnumeration()->elementAt(i)) ==0 )
  ------------------
  |  Branch (427:17): [True: 0, False: 0]
  ------------------
  428|      0|                break;
  429|      0|        }
  430|       |
  431|      0|        if (i == enumLength)
  ------------------
  |  Branch (431:13): [True: 0, False: 0]
  ------------------
  432|      0|            ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  433|      0|    }
  434|       |
  435|     16|    boundsCheck(compareData, manager);
  436|       |
  437|     16|    if ( (thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0 )
  ------------------
  |  Branch (437:10): [True: 16, False: 0]
  ------------------
  438|     16|    {
  439|     16|        if ( compareData->getScale() > fFractionDigits )
  ------------------
  |  Branch (439:14): [True: 0, False: 16]
  ------------------
  440|      0|        {
  441|      0|            XMLCh value1[BUF_LEN+1];
  442|      0|            XMLCh value2[BUF_LEN+1];
  443|      0|            XMLString::binToText(compareData->getScale(), value1, BUF_LEN, 10, manager);
  444|      0|            XMLString::binToText(fFractionDigits, value2, BUF_LEN, 10, manager);
  445|      0|            ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
  ------------------
  |  |  270|      0|#define ThrowXMLwithMemMgr3(type,code,p1,p2,p3,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, 0, memMgr)
  ------------------
  446|      0|                              , XMLExcepts::VALUE_exceed_fractDigit
  447|      0|                              , compareData->getRawData()
  448|      0|                              , value1
  449|      0|                              , value2
  450|      0|                              , manager);
  451|      0|        }
  452|     16|    }
  453|       |
  454|     16|    if ( (thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0 )
  ------------------
  |  Branch (454:10): [True: 0, False: 16]
  ------------------
  455|      0|    {
  456|      0|        if ( compareData->getTotalDigit() > fTotalDigits )
  ------------------
  |  Branch (456:14): [True: 0, False: 0]
  ------------------
  457|      0|        {
  458|      0|            XMLCh value1[BUF_LEN+1];
  459|      0|            XMLCh value2[BUF_LEN+1];
  460|      0|            XMLString::binToText(compareData->getTotalDigit(), value1, BUF_LEN, 10, manager);
  461|      0|            XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10, manager);
  462|      0|            ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
  ------------------
  |  |  270|      0|#define ThrowXMLwithMemMgr3(type,code,p1,p2,p3,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, 0, memMgr)
  ------------------
  463|      0|                              , XMLExcepts::VALUE_exceed_totalDigit
  464|      0|                              , compareData->getRawData()
  465|      0|                              , value1
  466|      0|                              , value2
  467|      0|                              , manager);
  468|      0|        }
  469|       |
  470|       |        /***
  471|       |         E2-44 totalDigits
  472|       |         ... by restricting it to numbers that are expressible as i x 10^-n
  473|       |         where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits.
  474|       |         ***/
  475|       |
  476|      0|        if ( compareData->getScale() > fTotalDigits )
  ------------------
  |  Branch (476:14): [True: 0, False: 0]
  ------------------
  477|      0|        {
  478|      0|            XMLCh value1[BUF_LEN+1];
  479|      0|            XMLCh value2[BUF_LEN+1];
  480|      0|            XMLString::binToText(compareData->getScale(), value1, BUF_LEN, 10, manager);
  481|      0|            XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10, manager);
  482|      0|            ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
  ------------------
  |  |  270|      0|#define ThrowXMLwithMemMgr3(type,code,p1,p2,p3,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, p3, 0, memMgr)
  ------------------
  483|      0|                              , XMLExcepts::VALUE_exceed_totalDigit
  484|      0|                              , compareData->getRawData()
  485|      0|                              , value1
  486|      0|                              , value2
  487|      0|                              , manager);
  488|      0|        }
  489|      0|    }
  490|     16|}

_ZN11xercesc_3_224DecimalDatatypeValidator17setFractionDigitsEj:
  208|     13|{
  209|     13|    fFractionDigits = newFractionDigits;
  210|     13|}

_ZN11xercesc_3_223DoubleDatatypeValidatorC2EPNS_13MemoryManagerE:
   36|      1|{
   37|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   38|      1|    setBounded(true);
   39|      1|    setFinite(true);
   40|      1|    setNumeric(true);
   41|      1|}

_ZN11xercesc_3_225DurationDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_223ENTITYDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   46|      1|{
   47|      1|    init(enums, manager);
   48|      1|}

_ZN11xercesc_3_222FloatDatatypeValidatorC2EPNS_13MemoryManagerE:
   37|      1|{
   38|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   39|      1|    setBounded(true);
   40|      1|    setFinite(true);
   41|      1|    setNumeric(true);
   42|      1|}

_ZN11xercesc_3_226HexBinaryDatatypeValidatorC2EPNS_13MemoryManagerE:
   37|      1|{}

_ZN11xercesc_3_219IDDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   45|      1|{
   46|      1|    init(enums, manager);
   47|      1|}

_ZN11xercesc_3_222IDREFDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   45|      1|{
   46|      1|    init(enums, manager);
   47|      1|}

_ZN11xercesc_3_221ListDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   50|      3|{
   51|       |    //
   52|       |    // baseValidator shall either
   53|       |    // an atomic DTV which servers as itemType, or
   54|       |    // another ListDTV from which, this ListDTV is derived by restriction.
   55|       |    //
   56|       |    // In either case, it shall be not null
   57|       |    //
   58|      3|    if (!baseValidator)
  ------------------
  |  Branch (58:9): [True: 0, False: 3]
  ------------------
   59|      0|        ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_List_Null_baseValidator, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
   60|       |
   61|      3|    init(enums, manager);
   62|      3|}
_ZN11xercesc_3_221ListDatatypeValidator16inspectFacetBaseEPNS_13MemoryManagerE:
  299|      3|{
  300|       |
  301|       |    //
  302|       |    // we are pretty sure baseValidator is not null
  303|       |    //
  304|       |
  305|      3|    if (getBaseValidator()->getType() == DatatypeValidator::List)
  ------------------
  |  Branch (305:9): [True: 0, False: 3]
  ------------------
  306|      0|    {
  307|      0|        AbstractStringValidator::inspectFacetBase(manager);
  308|      0|    }
  309|      3|    else
  310|      3|    {
  311|       |        // the first level ListDTV
  312|       |        // check 4.3.5.c0 must: enumeration values from the value space of base
  313|      3|        if ( ((getFacetsDefined() & DatatypeValidator::FACET_ENUMERATION) != 0) &&
  ------------------
  |  Branch (313:14): [True: 0, False: 3]
  ------------------
  314|      3|             (getEnumeration() !=0)                                              )
  ------------------
  |  Branch (314:14): [True: 0, False: 0]
  ------------------
  315|      0|        {
  316|      0|            XMLSize_t i;
  317|      0|            XMLSize_t enumLength = getEnumeration()->size();
  318|      0|            try
  319|      0|            {
  320|      0|                for ( i = 0; i < enumLength; i++)
  ------------------
  |  Branch (320:30): [True: 0, False: 0]
  ------------------
  321|      0|                {
  322|       |                    // ask the itemType for a complete check
  323|      0|                    BaseRefVectorOf<XMLCh>* tempList = XMLString::tokenizeString(getEnumeration()->elementAt(i), manager);
  324|      0|                    Janitor<BaseRefVectorOf<XMLCh> >    jan(tempList);
  325|      0|                    XMLSize_t tokenNumber = tempList->size();
  326|       |
  327|      0|                    try
  328|      0|                    {
  329|      0|                        for ( XMLSize_t j = 0; j < tokenNumber; j++)
  ------------------
  |  Branch (329:48): [True: 0, False: 0]
  ------------------
  330|      0|                            getBaseValidator()->validate(tempList->elementAt(j), (ValidationContext*)0, manager);
  331|      0|                    }
  332|      0|                    catch(const OutOfMemoryException&)
  333|      0|                    {
  334|      0|                        jan.release();
  335|       |
  336|      0|                        throw;
  337|      0|                    }
  338|       |#if 0
  339|       |// spec says that only base has to checkContent                    
  340|       |                    // enum shall pass this->checkContent() as well.
  341|       |                    checkContent(getEnumeration()->elementAt(i), (ValidationContext*)0, false, manager);
  342|       |#endif
  343|      0|                }
  344|      0|            }
  345|       |
  346|      0|            catch ( XMLException& )
  347|      0|            {
  348|      0|                ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  349|      0|                        , XMLExcepts::FACET_enum_base
  350|      0|                        , getEnumeration()->elementAt(i)
  351|      0|                        , manager);
  352|      0|            }
  353|       |
  354|      0|        }
  355|       |
  356|      3|    }
  357|       |
  358|      3|}// End of inspectFacetBase()
_ZN11xercesc_3_221ListDatatypeValidator12inheritFacetEv:
  361|      3|{
  362|       |
  363|       |    //iff the base validator is List, then we inherit
  364|       |    //
  365|      3|    if (getBaseValidator()->getType() == DatatypeValidator::List)
  ------------------
  |  Branch (365:9): [True: 0, False: 3]
  ------------------
  366|      0|    {
  367|      0|        AbstractStringValidator::inheritFacet();
  368|      0|    }
  369|       |
  370|      3|}

_ZN11xercesc_3_222MonthDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_225MonthDayDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_223NCNameDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   48|      1|{
   49|      1|    init(enums, manager);
   50|      1|}

_ZN11xercesc_3_225NOTATIONDatatypeValidatorC2EPNS_13MemoryManagerE:
   38|      1|{}

_ZN11xercesc_3_221NameDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   48|      1|{
   49|      1|    init(enums, manager);
   50|      1|}

_ZN11xercesc_3_222QNameDatatypeValidatorC2EPNS_13MemoryManagerE:
   38|      1|{}

_ZN11xercesc_3_223StringDatatypeValidatorC2EPNS_13MemoryManagerE:
   37|      1|{
   38|      1|    setWhiteSpace(DatatypeValidator::PRESERVE);
   39|      1|}
_ZN11xercesc_3_223StringDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   48|      4|{
   49|      4|    setWhiteSpace(DatatypeValidator::PRESERVE);
   50|      4|    init(enums, manager);
   51|      4|}
_ZN11xercesc_3_223StringDatatypeValidator11newInstanceEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEPNS_16RefArrayVectorOfIDsEEiPNS_13MemoryManagerE:
   63|      4|{
   64|      4|    return (DatatypeValidator*) new (manager) StringDatatypeValidator(this, facets, enums, finalSet, manager);
   65|      4|}
_ZN11xercesc_3_223StringDatatypeValidatorC2EPNS_17DatatypeValidatorEPNS_14RefHashTableOfINS_12KVStringPairENS_12StringHasherEEEiNS1_13ValidatorTypeEPNS_13MemoryManagerE:
   74|      5|{
   75|      5|    setWhiteSpace(DatatypeValidator::PRESERVE);
   76|       |    // do not invoke init() here!!!
   77|      5|}
_ZN11xercesc_3_223StringDatatypeValidator21assignAdditionalFacetEPKDsS2_PNS_13MemoryManagerE:
   85|      3|{
   86|      3|    if (XMLString::equals(key, SchemaSymbols::fgELT_WHITESPACE))
  ------------------
  |  Branch (86:9): [True: 3, False: 0]
  ------------------
   87|      3|    {
   88|       |        // whiteSpace = preserve | replace | collapse
   89|      3|        if (XMLString::equals(value, SchemaSymbols::fgWS_PRESERVE))
  ------------------
  |  Branch (89:13): [True: 0, False: 3]
  ------------------
   90|      0|            setWhiteSpace(DatatypeValidator::PRESERVE);
   91|      3|        else if (XMLString::equals(value, SchemaSymbols::fgWS_REPLACE))
  ------------------
  |  Branch (91:18): [True: 1, False: 2]
  ------------------
   92|      1|            setWhiteSpace(DatatypeValidator::REPLACE);
   93|      2|        else if (XMLString::equals(value, SchemaSymbols::fgWS_COLLAPSE))
  ------------------
  |  Branch (93:18): [True: 2, False: 0]
  ------------------
   94|      2|            setWhiteSpace(DatatypeValidator::COLLAPSE);
   95|      0|        else
   96|      0|            ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::FACET_Invalid_WS, value, manager);
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
   97|       |        //("whiteSpace value '" + ws + "' must be one of 'preserve', 'replace', 'collapse'.");
   98|       |
   99|      3|        setFacetsDefined(DatatypeValidator::FACET_WHITESPACE);
  100|      3|    }
  101|      0|    else
  102|      0|    {
  103|      0|        ThrowXMLwithMemMgr1(InvalidDatatypeFacetException
  ------------------
  |  |  266|      0|#define ThrowXMLwithMemMgr1(type,code,p1,memMgr) throw type(__FILE__, __LINE__, code, p1, 0, 0, 0, memMgr)
  ------------------
  104|      0|                , XMLExcepts::FACET_Invalid_Tag
  105|      0|                , key
  106|      0|                , manager);
  107|      0|    }
  108|      3|}
_ZN11xercesc_3_223StringDatatypeValidator22inheritAdditionalFacetEv:
  111|      9|{
  112|      9|    StringDatatypeValidator *pBaseValidator = (StringDatatypeValidator*) getBaseValidator();
  113|       |
  114|      9|    if (!pBaseValidator)
  ------------------
  |  Branch (114:9): [True: 0, False: 9]
  ------------------
  115|      0|        return;
  116|       |
  117|       |    // inherit whitespace
  118|      9|    if (((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) !=0) &&
  ------------------
  |  Branch (118:9): [True: 8, False: 1]
  ------------------
  119|      9|        ((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) == 0))
  ------------------
  |  Branch (119:9): [True: 6, False: 2]
  ------------------
  120|      6|    {
  121|      6|        setWhiteSpace(getBaseValidator()->getWSFacet());
  122|      6|        setFacetsDefined(DatatypeValidator::FACET_WHITESPACE);
  123|      6|    }
  124|      9|}
_ZNK11xercesc_3_223StringDatatypeValidator31checkAdditionalFacetConstraintsEPNS_13MemoryManagerE:
  127|      4|{
  128|       |
  129|      4|    StringDatatypeValidator *pBaseValidator = (StringDatatypeValidator*) getBaseValidator();
  130|       |
  131|      4|    if (!pBaseValidator)
  ------------------
  |  Branch (131:9): [True: 0, False: 4]
  ------------------
  132|      0|        return;
  133|       |
  134|      4|    short    thisWSFacet = getWSFacet();
  135|      4|    short    baseWSFacet = pBaseValidator->getWSFacet();
  136|       |
  137|       |    // check 4.3.6.c1 error: whitespace
  138|      4|    if (((getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0) &&
  ------------------
  |  Branch (138:9): [True: 3, False: 1]
  ------------------
  139|      4|        ((pBaseValidator->getFacetsDefined() & DatatypeValidator::FACET_WHITESPACE) != 0 ))
  ------------------
  |  Branch (139:9): [True: 2, False: 1]
  ------------------
  140|      2|    {
  141|      2|        if ((baseWSFacet == DatatypeValidator::COLLAPSE) &&
  ------------------
  |  Branch (141:13): [True: 1, False: 1]
  ------------------
  142|      2|            ((thisWSFacet == DatatypeValidator::PRESERVE) ||
  ------------------
  |  Branch (142:14): [True: 0, False: 1]
  ------------------
  143|      1|             (thisWSFacet == DatatypeValidator::REPLACE)))
  ------------------
  |  Branch (143:14): [True: 0, False: 1]
  ------------------
  144|      0|             ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_WS_collapse, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  145|       |
  146|      2|        if ((baseWSFacet == DatatypeValidator::REPLACE) &&
  ------------------
  |  Branch (146:13): [True: 1, False: 1]
  ------------------
  147|      2|            (thisWSFacet == DatatypeValidator::PRESERVE))
  ------------------
  |  Branch (147:13): [True: 0, False: 1]
  ------------------
  148|      0|            ThrowXMLwithMemMgr(InvalidDatatypeFacetException, XMLExcepts::FACET_WS_replace, manager);
  ------------------
  |  |  264|      0|#define ThrowXMLwithMemMgr(type,code,memMgr) throw type(__FILE__, __LINE__, code, memMgr)
  ------------------
  149|       |
  150|      2|        if (((pBaseValidator->getFixed() & DatatypeValidator::FACET_WHITESPACE) !=0) &&
  ------------------
  |  Branch (150:13): [True: 0, False: 2]
  ------------------
  151|      2|            ( thisWSFacet != baseWSFacet))
  ------------------
  |  Branch (151:13): [True: 0, False: 0]
  ------------------
  152|      0|        {
  153|      0|            ThrowXMLwithMemMgr2(InvalidDatatypeFacetException
  ------------------
  |  |  268|      0|#define ThrowXMLwithMemMgr2(type,code,p1,p2,memMgr) throw type(__FILE__, __LINE__, code, p1, p2, 0, 0, memMgr)
  ------------------
  154|      0|                        , XMLExcepts::FACET_whitespace_base_fixed
  155|      0|                        , getWSstring(thisWSFacet)
  156|      0|                        , getWSstring(baseWSFacet)
  157|      0|                        , manager);
  158|      0|        }
  159|      2|    }
  160|       |
  161|      4|}

_ZN11xercesc_3_221TimeDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_214XMLCanRepGroupC2ENS0_11CanRepGroupE:
   36|     14|{
   37|     14|}

_ZN11xercesc_3_221YearDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_226YearMonthDatatypeValidatorC2EPNS_13MemoryManagerE:
   35|      1|{
   36|      1|    setOrdered(XSSimpleTypeDefinition::ORDERED_PARTIAL);
   37|      1|}

_ZN11xercesc_3_214XMLInitializer25initializeComplexTypeInfoEv:
   45|      1|{
   46|       |  // create type name
   47|      1|  XMLCh typeName[128];
   48|      1|  XMLSize_t nsLen = XMLString::stringLen(SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
   49|       |
   50|      1|  XMLString::copyString(typeName, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
   51|      1|  typeName[nsLen] = chComma;
   52|      1|  XMLString::copyString(typeName + nsLen + 1, SchemaSymbols::fgATTVAL_ANYTYPE);
   53|       |
   54|       |  // Create and initialize 'anyType'
   55|      1|  ComplexTypeInfo::fAnyType = new ComplexTypeInfo();
   56|       |
   57|      1|  ContentSpecNode* term = new ContentSpecNode
   58|      1|    (
   59|      1|      new QName
   60|      1|      (
   61|      1|        XMLUni::fgZeroLenString
   62|      1|        , XMLUni::fgZeroLenString
   63|      1|        , 1
   64|      1|      )
   65|      1|      , false
   66|      1|    );
   67|      1|  term->setType(ContentSpecNode::Any_Lax);
   68|      1|  term->setMinOccurs(0);
   69|      1|  term->setMaxOccurs(SchemaSymbols::XSD_UNBOUNDED);
   70|       |
   71|      1|  ContentSpecNode* particle = new ContentSpecNode
   72|      1|    (
   73|      1|      ContentSpecNode::ModelGroupSequence
   74|      1|      , term
   75|      1|      , 0
   76|      1|    );
   77|       |
   78|      1|  SchemaAttDef* attWildCard = new SchemaAttDef
   79|      1|    (
   80|      1|      XMLUni::fgZeroLenString
   81|      1|      , XMLUni::fgZeroLenString
   82|      1|      , 1
   83|      1|      , XMLAttDef::Any_Any
   84|      1|      , XMLAttDef::ProcessContents_Lax
   85|      1|    );
   86|       |
   87|      1|  ComplexTypeInfo::fAnyType->setTypeName(typeName);
   88|      1|  ComplexTypeInfo::fAnyType->setBaseComplexTypeInfo(ComplexTypeInfo::fAnyType);
   89|      1|  ComplexTypeInfo::fAnyType->setDerivedBy(SchemaSymbols::XSD_RESTRICTION);
   90|      1|  ComplexTypeInfo::fAnyType->setContentType(SchemaElementDecl::Mixed_Complex);
   91|      1|  ComplexTypeInfo::fAnyType->setContentSpec(particle);
   92|      1|  ComplexTypeInfo::fAnyType->setAttWildCard(attWildCard);
   93|      1|}
_ZN11xercesc_3_215ComplexTypeInfoC2EPNS_13MemoryManagerE:
  140|      1|{
  141|      1|    fAttDefs = new (fMemoryManager) RefHash2KeysTableOf<SchemaAttDef>(29, true, fMemoryManager);
  142|      1|    fAttList = new (fMemoryManager) SchemaAttDefList(fAttDefs,fMemoryManager);
  143|      1|}
_ZN11xercesc_3_215ComplexTypeInfo14setContentSpecEPNS_15ContentSpecNodeE:
  182|      1|void ComplexTypeInfo::setContentSpec(ContentSpecNode* const toAdopt) {
  183|       |
  184|      1|    if (fContentSpec && fAdoptContentSpec) {
  ------------------
  |  Branch (184:9): [True: 0, False: 1]
  |  Branch (184:25): [True: 0, False: 0]
  ------------------
  185|      0|        delete fContentSpec;
  186|      0|    }
  187|       |
  188|      1|    fContentSpec = toAdopt;
  189|      1|}

_ZN11xercesc_3_215ComplexTypeInfo12setDerivedByEi:
  398|      1|inline void ComplexTypeInfo::setDerivedBy(const int derivedBy) {
  399|       |
  400|      1|    fDerivedBy = derivedBy;
  401|      1|}
_ZN11xercesc_3_215ComplexTypeInfo14setContentTypeEi:
  424|      1|ComplexTypeInfo::setContentType(const int contentType) {
  425|       |
  426|      1|    fContentType = contentType;
  427|      1|}
_ZN11xercesc_3_215ComplexTypeInfo11setTypeNameEPKDs:
  429|      1|inline void ComplexTypeInfo::setTypeName(const XMLCh* const typeName) {
  430|       |
  431|      1|    fMemoryManager->deallocate(fTypeName);//delete [] fTypeName;
  432|      1|    fMemoryManager->deallocate(fTypeLocalName);//delete [] fTypeLocalName;
  433|      1|    fMemoryManager->deallocate(fTypeUri);//delete [] fTypeUri;
  434|       |
  435|      1|    if (typeName)
  ------------------
  |  Branch (435:9): [True: 1, False: 0]
  ------------------
  436|      1|    {
  437|      1|        fTypeName = XMLString::replicate(typeName, fMemoryManager);
  438|       |
  439|      1|        int index = XMLString::indexOf(fTypeName, chComma);
  440|      1|        XMLSize_t length = XMLString::stringLen(fTypeName);
  441|      1|        fTypeLocalName = (XMLCh*) fMemoryManager->allocate
  442|      1|        (
  443|      1|            (length - index + 1) * sizeof(XMLCh)
  444|      1|        ); //new XMLCh[length - index + 1];
  445|      1|        XMLString::subString(fTypeLocalName, fTypeName, index + 1, length, fMemoryManager);
  446|       |
  447|      1|        fTypeUri = (XMLCh*) fMemoryManager->allocate
  448|      1|        (
  449|      1|            (index + 1) * sizeof(XMLCh)
  450|      1|        ); //new XMLCh[index + 1];
  451|      1|        XMLString::subString(fTypeUri, fTypeName, 0, index, fMemoryManager);
  452|      1|    }
  453|      0|    else
  454|      0|    {
  455|      0|        fTypeName = fTypeLocalName = fTypeUri = 0;
  456|      0|    }
  457|      1|}
_ZN11xercesc_3_215ComplexTypeInfo22setBaseComplexTypeInfoEPS0_:
  472|      1|ComplexTypeInfo::setBaseComplexTypeInfo(ComplexTypeInfo* const typeInfo) {
  473|       |
  474|      1|    fBaseComplexTypeInfo = typeInfo;
  475|      1|}
_ZN11xercesc_3_215ComplexTypeInfo14setAttWildCardEPNS_12SchemaAttDefE:
  489|      1|inline void ComplexTypeInfo::setAttWildCard(SchemaAttDef* const toAdopt) {
  490|       |
  491|      1|    if (fAttWildCard) {
  ------------------
  |  Branch (491:9): [True: 0, False: 1]
  ------------------
  492|      0|       delete fAttWildCard;
  493|      0|    }
  494|       |
  495|      1|    fAttWildCard = toAdopt;
  496|      1|}

_ZN11xercesc_3_214XMLInitializer31initializeGeneralAttributeCheckEv:
   66|      1|{
   67|      1|    GeneralAttributeCheck::initialize ();
   68|      1|}
_ZN11xercesc_3_221GeneralAttributeCheck10initializeEv:
   84|      1|{
   85|       |    // Set up validators.
   86|       |    //
   87|      1|    DatatypeValidatorFactory dvFactory;
   88|       |
   89|      1|    fNonNegIntDV = dvFactory.getDatatypeValidator(SchemaSymbols::fgDT_NONNEGATIVEINTEGER);
   90|      1|    fBooleanDV = dvFactory.getDatatypeValidator(SchemaSymbols::fgDT_BOOLEAN);
   91|      1|    fAnyURIDV = dvFactory.getDatatypeValidator(SchemaSymbols::fgDT_ANYURI);
   92|       |
   93|       |    // TODO - add remaining valdiators
   94|       |
   95|       |    // Map attributes.
   96|       |    //
   97|      1|    fAttMap = new ValueHashTableOf<unsigned short>(A_Count);
   98|       |
   99|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_ABSTRACT, A_Abstract);
  100|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_ATTRIBUTEFORMDEFAULT, A_AttributeFormDefault);
  101|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_BASE, A_Base);
  102|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_BLOCK, A_Block);
  103|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_BLOCKDEFAULT, A_BlockDefault);
  104|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_DEFAULT, A_Default);
  105|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_ELEMENTFORMDEFAULT, A_ElementFormDefault);
  106|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_FINAL, A_Final);
  107|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_FINALDEFAULT, A_FinalDefault);
  108|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_FIXED, A_Fixed);
  109|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_FORM, A_Form);
  110|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_ID, A_ID);
  111|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_ITEMTYPE, A_ItemType);
  112|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_MAXOCCURS, A_MaxOccurs);
  113|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_MEMBERTYPES, A_MemberTypes);
  114|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_MINOCCURS, A_MinOccurs);
  115|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_MIXED, A_Mixed);
  116|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_NAME, A_Name);
  117|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_NAMESPACE, A_Namespace);
  118|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_NILLABLE, A_Nillable);
  119|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_PROCESSCONTENTS, A_ProcessContents);
  120|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_PUBLIC, A_Public);
  121|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_REF, A_Ref);
  122|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_REFER, A_Refer);
  123|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_SCHEMALOCATION, A_SchemaLocation);
  124|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_SOURCE, A_Source);
  125|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_SUBSTITUTIONGROUP, A_SubstitutionGroup);
  126|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_SYSTEM, A_System);
  127|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_TARGETNAMESPACE, A_TargetNamespace);
  128|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_TYPE, A_Type);
  129|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_USE, A_Use);
  130|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_VALUE, A_Value);
  131|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_VERSION, A_Version);
  132|      1|    fAttMap->put((void*)SchemaSymbols::fgATT_XPATH, A_XPath);
  133|       |
  134|      1|    fFacetsMap = new ValueHashTableOf<unsigned short>(13);
  135|       |
  136|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_MINEXCLUSIVE, E_MinExclusive);
  137|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_MININCLUSIVE, E_MinInclusive);
  138|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_MAXEXCLUSIVE, E_MaxExclusive);
  139|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_MAXINCLUSIVE, E_MaxInclusive);
  140|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_TOTALDIGITS, E_TotalDigits);
  141|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_FRACTIONDIGITS, E_FractionDigits);
  142|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_LENGTH, E_Length);
  143|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_MINLENGTH, E_MinLength);
  144|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_MAXLENGTH, E_MaxLength);
  145|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_ENUMERATION, E_Enumeration);
  146|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_WHITESPACE, E_WhiteSpace);
  147|      1|    fFacetsMap->put((void*) SchemaSymbols::fgELT_PATTERN, E_Pattern);
  148|      1|}

_ZN11xercesc_3_212SchemaAttDefC2EPKDsS2_iNS_9XMLAttDef8AttTypesENS3_11DefAttTypesEPNS_13MemoryManagerE:
   67|      1|{
   68|      1|    fAttName = new (manager) QName(prefix, localPart, uriId, manager);
   69|      1|}

_ZN11xercesc_3_216SchemaAttDefListC2EPNS_19RefHash2KeysTableOfINS_12SchemaAttDefENS_12StringHasherEEEPNS_13MemoryManagerE:
   43|      1|{
   44|      1|    fEnum = new (getMemoryManager()) RefHash2KeysTableOfEnumerator<SchemaAttDef>(listToUse, false, getMemoryManager());
   45|      1|    fArray = (SchemaAttDef **)((getMemoryManager())->allocate( sizeof(SchemaAttDef*) << 1));
   46|      1|    fSize = 2;
   47|      1|}

_ZN11xercesc_3_215SchemaValidatorC2EPNS_16XMLErrorReporterEPNS_13MemoryManagerE:
   70|  8.51k|{
   71|  8.51k|    fTypeStack = new (fMemoryManager) ValueStackOf<ComplexTypeInfo*>(8, fMemoryManager);
   72|  8.51k|}
_ZN11xercesc_3_215SchemaValidatorD2Ev:
   75|  8.51k|{
   76|  8.51k|    delete fXsiType;
   77|  8.51k|    delete fTypeStack;
   78|       |
   79|  8.51k|    if (fNotationBuf)
  ------------------
  |  Branch (79:9): [True: 0, False: 8.51k]
  ------------------
   80|      0|        delete fNotationBuf;
   81|  8.51k|}
_ZN11xercesc_3_215SchemaValidator5resetEv:
  338|  8.51k|{
  339|  8.51k|    fTrailing = false;
  340|  8.51k|    fSeenNonWhiteSpace = false;
  341|  8.51k|    fSeenId = false;
  342|  8.51k|	fTypeStack->removeAllElements();
  343|  8.51k|    delete fXsiType;
  344|  8.51k|    fXsiType = 0;
  345|  8.51k|    fCurrentDatatypeValidator = 0;
  346|  8.51k|    fNil = false;
  347|  8.51k|    fNilFound = false;
  348|  8.51k|    fDatatypeBuffer.reset();
  349|  8.51k|    fErrorOccurred = false;
  350|  8.51k|}

_ZN11xercesc_3_215SchemaValidator16setErrorReporterEPNS_16XMLErrorReporterE:
  383|  8.51k|inline void SchemaValidator::setErrorReporter(XMLErrorReporter* const errorReporter) {
  384|       |
  385|  8.51k|    XMLValidator::setErrorReporter(errorReporter);
  386|  8.51k|    fSchemaErrorReporter.setErrorReporter(errorReporter);
  387|  8.51k|}
_ZN11xercesc_3_215SchemaValidator19setExitOnFirstFatalEb:
  339|  8.51k|inline void SchemaValidator::setExitOnFirstFatal(const bool newValue) {
  340|       |
  341|  8.51k|    fSchemaErrorReporter.setExitOnFirstFatal(newValue);
  342|  8.51k|}
_ZN11xercesc_3_215SchemaValidator18setGrammarResolverEPNS_15GrammarResolverE:
  317|  8.51k|inline void SchemaValidator::setGrammarResolver(GrammarResolver* grammarResolver) {
  318|  8.51k|    fGrammarResolver = grammarResolver;
  319|  8.51k|}

_ZN11xercesc_3_214XMLInitializer26initializeXSDErrorReporterEv:
   40|      1|{
   41|      1|    gErrMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgXMLErrDomain);
   42|       |
   43|      1|    if (!gErrMsgLoader)
  ------------------
  |  Branch (43:9): [True: 0, False: 1]
  ------------------
   44|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   45|       |
   46|      1|    gValidMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgValidityDomain);
   47|       |
   48|      1|    if (!gValidMsgLoader)
  ------------------
  |  Branch (48:9): [True: 0, False: 1]
  ------------------
   49|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   50|      1|}
_ZN11xercesc_3_216XSDErrorReporterC2EPNS_16XMLErrorReporterE:
   67|  8.51k|{
   68|       |
   69|  8.51k|}

_ZN11xercesc_3_216XSDErrorReporterD2Ev:
   45|  8.51k|    {
   46|  8.51k|    }
_ZN11xercesc_3_216XSDErrorReporter19setExitOnFirstFatalEb:
  104|  8.51k|{
  105|  8.51k|    fExitOnFirstFatal = newValue;
  106|  8.51k|}
_ZN11xercesc_3_216XSDErrorReporter16setErrorReporterEPNS_16XMLErrorReporterE:
  109|  8.51k|{
  110|  8.51k|    fErrorReporter = errorReporter;
  111|  8.51k|}

_ZN11xercesc_3_214FieldActivatorC2EPNS_15ValueStoreCacheEPNS_17XPathMatcherStackEPNS_13MemoryManagerE:
   42|  8.51k|{
   43|  8.51k|    fMayMatch = new (manager) ValueHashTableOf<bool, PtrHasher>(29, manager);
   44|  8.51k|}
_ZN11xercesc_3_214FieldActivatorD2Ev:
   66|  8.51k|{
   67|  8.51k|    delete fMayMatch;
   68|  8.51k|}

_ZN11xercesc_3_225IdentityConstraintHandlerC2EPNS_10XMLScannerEPNS_13MemoryManagerE:
   49|  8.51k|{
   50|  8.51k|    CleanupType cleanup(this, &IdentityConstraintHandler::cleanUp);
   51|       |
   52|  8.51k|    try {
   53|       |
   54|  8.51k|        fMatcherStack    = new (fMemoryManager) XPathMatcherStack(fMemoryManager);
   55|  8.51k|        fValueStoreCache = new (fMemoryManager) ValueStoreCache(fMemoryManager);
   56|  8.51k|        fFieldActivator  = new (fMemoryManager) FieldActivator(fValueStoreCache, fMatcherStack, fMemoryManager);
   57|       |
   58|  8.51k|        fValueStoreCache->setScanner(scanner);
   59|  8.51k|    }
   60|  8.51k|    catch(const OutOfMemoryException&)
   61|  8.51k|    {
   62|      0|        cleanup.release();
   63|       |
   64|      0|        throw;
   65|      0|    }
   66|       |
   67|  8.51k|    cleanup.release();
   68|  8.51k|}
_ZN11xercesc_3_225IdentityConstraintHandlerD2Ev:
   71|  8.51k|{
   72|  8.51k|    cleanUp();
   73|  8.51k|}
_ZN11xercesc_3_225IdentityConstraintHandler7cleanUpEv:
  192|  8.51k|{
  193|  8.51k|    if (fMatcherStack)
  ------------------
  |  Branch (193:9): [True: 8.51k, False: 0]
  ------------------
  194|  8.51k|        delete fMatcherStack;
  195|       |
  196|  8.51k|    if (fValueStoreCache)
  ------------------
  |  Branch (196:9): [True: 8.51k, False: 0]
  ------------------
  197|  8.51k|        delete fValueStoreCache;
  198|       |
  199|  8.51k|    if (fFieldActivator)
  ------------------
  |  Branch (199:9): [True: 8.51k, False: 0]
  ------------------
  200|  8.51k|        delete fFieldActivator;
  201|       |
  202|  8.51k|}
_ZN11xercesc_3_225IdentityConstraintHandler5resetEv:
  205|  8.51k|{
  206|  8.51k|    fValueStoreCache->startDocument();
  207|  8.51k|    fMatcherStack->clear();
  208|  8.51k|}

_ZN11xercesc_3_215ValueStoreCacheC2EPNS_13MemoryManagerE:
   44|  8.51k|{
   45|  8.51k|    CleanupType cleanup(this, &ValueStoreCache::cleanUp);
   46|       |
   47|  8.51k|    try {
   48|  8.51k|        init();
   49|  8.51k|    }
   50|  8.51k|    catch(const OutOfMemoryException&)
   51|  8.51k|    {
   52|      0|        cleanup.release();
   53|       |
   54|      0|        throw;
   55|      0|    }
   56|       |
   57|  8.51k|    cleanup.release();
   58|  8.51k|}
_ZN11xercesc_3_215ValueStoreCacheD2Ev:
   62|  8.51k|{
   63|  8.51k|    cleanUp();
   64|  8.51k|}
_ZN11xercesc_3_215ValueStoreCache13startDocumentEv:
   69|  8.51k|void ValueStoreCache::startDocument() {
   70|       |
   71|  8.51k|    fIC2ValueStoreMap->removeAll();
   72|  8.51k|    fGlobalICMap->removeAll();
   73|  8.51k|    fValueStores->removeAllElements();
   74|  8.51k|    fGlobalMapStack->removeAllElements();
   75|  8.51k|}
_ZN11xercesc_3_215ValueStoreCache7cleanUpEv:
  117|  8.51k|void ValueStoreCache::cleanUp() {
  118|       |
  119|  8.51k|    delete fIC2ValueStoreMap;
  120|  8.51k|    delete fGlobalICMap;
  121|  8.51k|    delete fGlobalMapStack;
  122|  8.51k|    delete fValueStores;
  123|  8.51k|}
_ZN11xercesc_3_215ValueStoreCache4initEv:
  125|  8.51k|void ValueStoreCache::init() {
  126|       |
  127|  8.51k|    fValueStores = new (fMemoryManager) RefVectorOf<ValueStore>(8, false, fMemoryManager);
  128|  8.51k|    fGlobalICMap = new (fMemoryManager) RefHashTableOf<ValueStore, PtrHasher>
  129|  8.51k|    (
  130|  8.51k|        13
  131|  8.51k|        , false
  132|  8.51k|        , fMemoryManager
  133|  8.51k|    );
  134|  8.51k|    fIC2ValueStoreMap = new (fMemoryManager) RefHash2KeysTableOf<ValueStore, PtrHasher>
  135|  8.51k|    (
  136|  8.51k|        13
  137|  8.51k|        , true
  138|  8.51k|        , fMemoryManager
  139|  8.51k|    );
  140|  8.51k|    fGlobalMapStack = new (fMemoryManager) RefStackOf<RefHashTableOf<ValueStore, PtrHasher> >(8, true, fMemoryManager);
  141|  8.51k|}

_ZN11xercesc_3_215ValueStoreCache10setScannerEPNS_10XMLScannerE:
  134|  8.51k|inline void ValueStoreCache::setScanner(XMLScanner* const scanner) {
  135|       |
  136|  8.51k|    fScanner = scanner;
  137|  8.51k|}

_ZN11xercesc_3_217XPathMatcherStackC2EPNS_13MemoryManagerE:
   40|  8.51k|{
   41|  8.51k|    CleanupType cleanup(this, &XPathMatcherStack::cleanUp);
   42|       |
   43|  8.51k|    try {
   44|  8.51k|        fContextStack = new (manager) ValueStackOf<int>(8, manager);
   45|  8.51k|        fMatchers = new (manager) RefVectorOf<XPathMatcher>(8, true, manager);
   46|  8.51k|    }
   47|  8.51k|    catch(const OutOfMemoryException&)
   48|  8.51k|    {
   49|      0|        cleanup.release();
   50|       |
   51|      0|        throw;
   52|      0|    }
   53|       |
   54|  8.51k|    cleanup.release();
   55|  8.51k|}
_ZN11xercesc_3_217XPathMatcherStackD2Ev:
   57|  8.51k|XPathMatcherStack::~XPathMatcherStack() {
   58|       |
   59|  8.51k|    cleanUp();
   60|  8.51k|}
_ZN11xercesc_3_217XPathMatcherStack7cleanUpEv:
   66|  8.51k|{
   67|  8.51k|    delete fContextStack;
   68|  8.51k|    delete fMatchers;
   69|  8.51k|}
_ZN11xercesc_3_217XPathMatcherStack5clearEv:
   74|  8.51k|void XPathMatcherStack::clear() {
   75|       |
   76|  8.51k|    fContextStack->removeAllElements();
   77|  8.51k|    fMatchers->removeAllElements();
   78|  8.51k|    fMatchersCount = 0;
   79|  8.51k|}

_ZN11xercesc_3_214XMLInitializer18initializeXIncludeEv:
   45|      1|{
   46|      1|    gMsgLoader = XMLPlatformUtils::loadMsgSet(XMLUni::fgXMLErrDomain);
   47|       |
   48|      1|    if (!gMsgLoader)
  ------------------
  |  Branch (48:9): [True: 0, False: 1]
  ------------------
   49|      0|      XMLPlatformUtils::panic(PanicHandler::Panic_CantLoadMsgDomain);
   50|      1|}

_Z13parseInMemoryPKhm:
   23|  8.51k|{
   24|  8.51k|    if (!initialized)
  ------------------
  |  Branch (24:9): [True: 1, False: 8.51k]
  ------------------
   25|      1|    {
   26|      1|        XMLPlatformUtils::Initialize();
   27|      1|        initialized = true;
   28|      1|    }
   29|  8.51k|    SAXParser::ValSchemes valScheme = SAXParser::Val_Auto;
   30|  8.51k|    bool doNamespaces = false;
   31|  8.51k|    bool doSchema = false;
   32|  8.51k|    bool schemaFullChecking = false;
   33|  8.51k|    SAXParser *parser = new SAXParser;
   34|  8.51k|    parser->setValidationScheme(valScheme);
   35|  8.51k|    parser->setDoNamespaces(doNamespaces);
   36|  8.51k|    parser->setDoSchema(doSchema);
   37|  8.51k|    parser->setHandleMultipleImports(true);
   38|  8.51k|    parser->setValidationSchemaFullChecking(schemaFullChecking);
   39|  8.51k|    static const char *gMemBufId = "prodInfo";
   40|       |
   41|  8.51k|    MemBufInputSource *memBufIS = new MemBufInputSource(
   42|  8.51k|        (const XMLByte *)Data, Size, gMemBufId, false);
   43|  8.51k|    parser->parse(*memBufIS);
   44|  8.51k|    delete parser;
   45|  8.51k|    delete memBufIS;
   46|       |    //XMLPlatformUtils::Terminate();
   47|  8.51k|}

_ZN14xmlProtoFuzzer14ProtoConverter14removeNonAsciiERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   25|  2.06M|{
   26|  2.06M|	string asciiStr{_utf8};
   27|  2.06M|	asciiStr.erase(remove_if(asciiStr.begin(), asciiStr.end(), [=](char c) -> bool {
   28|  2.06M|                        return !(std::isalpha(c) || std::isdigit(c));
   29|  2.06M|                }), asciiStr.end());
   30|  2.06M|	return asciiStr.empty() ? "fuzz" : asciiStr;
  ------------------
  |  Branch (30:9): [True: 1.93M, False: 126k]
  ------------------
   31|  2.06M|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_4MiscE:
   35|  4.61k|{
   36|  4.61k|	switch (_x.misc_oneof_case())
  ------------------
  |  Branch (36:10): [True: 0, False: 4.61k]
  ------------------
   37|  4.61k|	{
   38|  1.72k|	case Misc::kComment:
  ------------------
  |  Branch (38:2): [True: 1.72k, False: 2.88k]
  ------------------
   39|  1.72k|		m_output << "<!--" << _x.comment() << "-->\n";
   40|  1.72k|		break;
   41|  1.37k|	case Misc::kInst:
  ------------------
  |  Branch (41:2): [True: 1.37k, False: 3.24k]
  ------------------
   42|  1.37k|		visit(_x.inst());
   43|  1.37k|		break;
   44|  1.51k|	case Misc::MISC_ONEOF_NOT_SET:
  ------------------
  |  Branch (44:2): [True: 1.51k, False: 3.09k]
  ------------------
   45|  1.51k|		break;
   46|  4.61k|	}
   47|  4.61k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_6PrologE:
   50|  8.51k|{
   51|  8.51k|	visit(_x.decl());
   52|  8.51k|	visit(_x.doctype());
   53|  8.51k|	for (auto const& misc: _x.misc())
  ------------------
  |  Branch (53:23): [True: 2.70k, False: 8.51k]
  ------------------
   54|  2.70k|		visit(misc);
   55|  8.51k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_8KeyValueE:
   58|  31.7k|{
   59|  31.7k|	if (!KeyValue::XmlNamespace_IsValid(_x.type()))
  ------------------
  |  Branch (59:6): [True: 196, False: 31.5k]
  ------------------
   60|    196|		return;
   61|       |
   62|  31.5k|	switch (_x.type())
  ------------------
  |  Branch (62:10): [True: 0, False: 31.5k]
  ------------------
   63|  31.5k|	{
   64|  7.11k|	case KeyValue::ATTRIBUTES:
  ------------------
  |  Branch (64:2): [True: 7.11k, False: 24.4k]
  ------------------
   65|  7.11k|		m_output << "xml:attributes=\"" << removeNonAscii(_x.value()) << "\" ";
   66|  7.11k|		break;
   67|  1.67k|	case KeyValue::BASE:
  ------------------
  |  Branch (67:2): [True: 1.67k, False: 29.8k]
  ------------------
   68|  1.67k|		m_output << "xml:base=\"" << removeNonAscii(_x.value()) << "\" ";
   69|  1.67k|		break;
   70|  1.52k|	case KeyValue::CATALOG:
  ------------------
  |  Branch (70:2): [True: 1.52k, False: 30.0k]
  ------------------
   71|  1.52k|		m_output << "xml:catalog=\"" << removeNonAscii(_x.value()) << "\" ";
   72|  1.52k|		break;
   73|  2.77k|	case KeyValue::ID:
  ------------------
  |  Branch (73:2): [True: 2.77k, False: 28.7k]
  ------------------
   74|  2.77k|		m_output << "xml:id=\"" << removeNonAscii(_x.value()) << "\" ";
   75|  2.77k|		break;
   76|  3.44k|	case KeyValue::LANG:
  ------------------
  |  Branch (76:2): [True: 3.44k, False: 28.0k]
  ------------------
   77|  3.44k|		m_output << "xml:lang=\"" << removeNonAscii(_x.value()) << "\" ";
   78|  3.44k|		break;
   79|  1.12k|	case KeyValue::LINK:
  ------------------
  |  Branch (79:2): [True: 1.12k, False: 30.4k]
  ------------------
   80|  1.12k|		m_output << "xml:link=\"" << removeNonAscii(_x.value()) << "\" ";
   81|  1.12k|		break;
   82|    728|	case KeyValue::SPACE:
  ------------------
  |  Branch (82:2): [True: 728, False: 30.8k]
  ------------------
   83|    728|		m_output << "xml:space=\"" << removeNonAscii(_x.value()) << "\" ";
   84|    728|		break;
   85|    967|	case KeyValue::SPECIAL:
  ------------------
  |  Branch (85:2): [True: 967, False: 30.5k]
  ------------------
   86|    967|		m_output << "xml:special=\"" << removeNonAscii(_x.value()) << "\" ";
   87|    967|		break;
   88|  1.46k|	case KeyValue::TEST:
  ------------------
  |  Branch (88:2): [True: 1.46k, False: 30.0k]
  ------------------
   89|  1.46k|		m_output << "xml:test=\"" << removeNonAscii(_x.value()) << "\" ";
   90|  1.46k|		break;
   91|  10.7k|	case KeyValue::FUZZ:
  ------------------
  |  Branch (91:2): [True: 10.7k, False: 20.8k]
  ------------------
   92|  10.7k|		if (_x.ByteSizeLong() % 2)
  ------------------
  |  Branch (92:7): [True: 2.16k, False: 8.55k]
  ------------------
   93|  2.16k|			m_output << "xmlns:" << removeNonAscii(_x.key()) << "=\"" << removeNonAscii(_x.value()) << "\" ";
   94|  8.55k|		else
   95|  8.55k|			m_output << removeNonAscii(_x.key()) << "=\"" << removeNonAscii(_x.value()) << "\" ";
   96|  10.7k|		break;
   97|      0|	case KeyValue_XmlNamespace_KeyValue_XmlNamespace_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (97:2): [True: 0, False: 31.5k]
  ------------------
   98|      0|	case KeyValue_XmlNamespace_KeyValue_XmlNamespace_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (98:2): [True: 0, False: 31.5k]
  ------------------
   99|      0|		break;
  100|  31.5k|	}
  101|  31.5k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_21ProcessingInstructionE:
  104|  1.37k|{
  105|  1.37k|	m_output << "<?" << removeNonAscii(_x.name()) << " ";
  106|  1.37k|	for (auto const& prop: _x.kv())
  ------------------
  |  Branch (106:23): [True: 1.05k, False: 1.37k]
  ------------------
  107|  1.05k|		visit(prop);
  108|  1.37k|	m_output << "?>\n";
  109|  1.37k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_7ContentE:
  112|   410k|{
  113|   410k|	switch (_x.content_oneof_case())
  ------------------
  |  Branch (113:10): [True: 0, False: 410k]
  ------------------
  114|   410k|	{
  115|  2.54k|	case Content::kStr:
  ------------------
  |  Branch (115:2): [True: 2.54k, False: 408k]
  ------------------
  116|  2.54k|		m_output << _x.str() << "\n";
  117|  2.54k|		break;
  118|  6.58k|	case Content::kE:
  ------------------
  |  Branch (118:2): [True: 6.58k, False: 404k]
  ------------------
  119|  6.58k|		visit(_x.e());
  120|  6.58k|		m_output << "\n";
  121|  6.58k|		break;
  122|  3.27k|	case Content::kC:
  ------------------
  |  Branch (122:2): [True: 3.27k, False: 407k]
  ------------------
  123|  3.27k|		visit(_x.c());
  124|  3.27k|		m_output << "\n";
  125|  3.27k|		break;
  126|   398k|	case Content::CONTENT_ONEOF_NOT_SET:
  ------------------
  |  Branch (126:2): [True: 398k, False: 12.4k]
  ------------------
  127|   398k|		break;
  128|   410k|	}
  129|   410k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_11ElementDeclE:
  132|  5.70k|{
  133|  5.70k|	if (!ElementDecl::ContentSpec_IsValid(_x.spec()))
  ------------------
  |  Branch (133:6): [True: 34, False: 5.66k]
  ------------------
  134|     34|		return;
  135|       |
  136|  5.66k|	m_output << "<!ELEMENT " << _x.name() << " ";
  137|  5.66k|	switch (_x.spec())
  ------------------
  |  Branch (137:10): [True: 0, False: 5.66k]
  ------------------
  138|  5.66k|	{
  139|  3.43k|	case ElementDecl::EMPTY:
  ------------------
  |  Branch (139:2): [True: 3.43k, False: 2.22k]
  ------------------
  140|  3.43k|		m_output << "EMPTY>";
  141|  3.43k|		break;
  142|    329|	case ElementDecl::ANY:
  ------------------
  |  Branch (142:2): [True: 329, False: 5.33k]
  ------------------
  143|    329|		m_output << "ANY>";
  144|    329|		break;
  145|    105|	case ElementDecl::FUZZ:
  ------------------
  |  Branch (145:2): [True: 105, False: 5.56k]
  ------------------
  146|    105|		m_output << "FUZZ>";
  147|    105|		break;
  148|  1.11k|	case ElementDecl::MIXED:
  ------------------
  |  Branch (148:2): [True: 1.11k, False: 4.55k]
  ------------------
  149|  1.11k|		m_output << "(#PCDATA";
  150|  1.11k|		for (auto const& pcdata: _x.cdata())
  ------------------
  |  Branch (150:26): [True: 2.91k, False: 1.11k]
  ------------------
  151|  2.91k|			m_output << "|" << pcdata;
  152|  1.11k|		m_output << ")";
  153|  1.11k|		if (_x.cdata_size() > 0)
  ------------------
  |  Branch (153:7): [True: 759, False: 352]
  ------------------
  154|    759|			m_output << "*";
  155|  1.11k|		m_output << ">";
  156|  1.11k|		break;
  157|    683|	case ElementDecl::CHILDREN:
  ------------------
  |  Branch (157:2): [True: 683, False: 4.98k]
  ------------------
  158|    683|	{
  159|    683|		m_output << "(";
  160|    683|		string delim = "";
  161|  3.26k|		for (auto const& str: _x.cdata()) {
  ------------------
  |  Branch (161:23): [True: 3.26k, False: 683]
  ------------------
  162|  3.26k|			m_output << delim << removeNonAscii(str);
  163|  3.26k|			delim = ", ";
  164|  3.26k|		}
  165|    683|		m_output << ")>";
  166|    683|		break;
  167|      0|	}
  168|      0|	case ElementDecl_ContentSpec_ElementDecl_ContentSpec_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (168:2): [True: 0, False: 5.66k]
  ------------------
  169|      0|	case ElementDecl_ContentSpec_ElementDecl_ContentSpec_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (169:2): [True: 0, False: 5.66k]
  ------------------
  170|      0|		break;
  171|  5.66k|	}
  172|  5.66k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_8AttValueE:
  175|  3.16k|{
  176|  3.16k|	if (!isValid(_x))
  ------------------
  |  Branch (176:6): [True: 331, False: 2.83k]
  ------------------
  177|    331|		return;
  178|       |
  179|  2.83k|	m_output << "\"";
  180|  2.83k|	string prefix;
  181|  2.83k|	switch (_x.type())
  ------------------
  |  Branch (181:10): [True: 0, False: 2.83k]
  ------------------
  182|  2.83k|	{
  183|  1.43k|	case AttValue::ENTITY:
  ------------------
  |  Branch (183:2): [True: 1.43k, False: 1.39k]
  ------------------
  184|  1.43k|		prefix = "&";
  185|  1.43k|		break;
  186|  1.05k|	case AttValue::CHAR:
  ------------------
  |  Branch (186:2): [True: 1.05k, False: 1.78k]
  ------------------
  187|  1.05k|		if (_x.ByteSizeLong() % 2)
  ------------------
  |  Branch (187:7): [True: 347, False: 703]
  ------------------
  188|    347|			prefix = "&#";
  189|    703|		else
  190|       |			// TODO: Value that follows this must be a
  191|       |			// sequence of hex digits.
  192|    703|			prefix = "&#x";
  193|  1.05k|		break;
  194|    349|	case AttValue::FUZZ:
  ------------------
  |  Branch (194:2): [True: 349, False: 2.48k]
  ------------------
  195|    349|		prefix = "fuzz";
  196|    349|		break;
  197|      0|	case AttValue_Type_AttValue_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (197:2): [True: 0, False: 2.83k]
  ------------------
  198|      0|	case AttValue_Type_AttValue_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (198:2): [True: 0, False: 2.83k]
  ------------------
  199|      0|		break;
  200|  2.83k|	}
  201|  2.83k|	for (auto const& name: _x.value())
  ------------------
  |  Branch (201:23): [True: 3.03k, False: 2.83k]
  ------------------
  202|  3.03k|		m_output << prefix << removeNonAscii(name) << ";";
  203|  2.83k|	m_output << "\"";
  204|  2.83k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_11DefaultDeclE:
  207|  18.7k|{
  208|  18.7k|	if (!isValid(_x))
  ------------------
  |  Branch (208:6): [True: 213, False: 18.5k]
  ------------------
  209|    213|		return;
  210|       |
  211|  18.5k|	switch (_x.type())
  ------------------
  |  Branch (211:10): [True: 0, False: 18.5k]
  ------------------
  212|  18.5k|	{
  213|  14.6k|	case DefaultDecl::REQUIRED:
  ------------------
  |  Branch (213:2): [True: 14.6k, False: 3.88k]
  ------------------
  214|  14.6k|		m_output << "#REQUIRED";
  215|  14.6k|		break;
  216|    433|	case DefaultDecl::IMPLIED:
  ------------------
  |  Branch (216:2): [True: 433, False: 18.1k]
  ------------------
  217|    433|		m_output << "#IMPLIED";
  218|    433|		break;
  219|  3.16k|	case DefaultDecl::FIXED:
  ------------------
  |  Branch (219:2): [True: 3.16k, False: 15.4k]
  ------------------
  220|  3.16k|		m_output << "#FIXED ";
  221|  3.16k|		visit(_x.att());
  222|  3.16k|		break;
  223|    280|	case DefaultDecl::FUZZ:
  ------------------
  |  Branch (223:2): [True: 280, False: 18.2k]
  ------------------
  224|    280|		m_output << "#FUZZ";
  225|    280|		break;
  226|      0|	case DefaultDecl_Type_DefaultDecl_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (226:2): [True: 0, False: 18.5k]
  ------------------
  227|      0|	case DefaultDecl_Type_DefaultDecl_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (227:2): [True: 0, False: 18.5k]
  ------------------
  228|      0|		break;
  229|  18.5k|	}
  230|  18.5k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_6AttDefE:
  233|  18.8k|{
  234|  18.8k|	if (!isValid(_x))
  ------------------
  |  Branch (234:6): [True: 38, False: 18.7k]
  ------------------
  235|     38|		return;
  236|       |
  237|  18.7k|	m_output << " " << removeNonAscii(_x.name()) << " ";
  238|  18.7k|	switch (_x.type())
  ------------------
  |  Branch (238:10): [True: 0, False: 18.7k]
  ------------------
  239|  18.7k|	{
  240|  12.8k|	case AttDef::CDATA:
  ------------------
  |  Branch (240:2): [True: 12.8k, False: 5.89k]
  ------------------
  241|  12.8k|		m_output << "CDATA ";
  242|  12.8k|		break;
  243|  2.69k|	case AttDef::ID:
  ------------------
  |  Branch (243:2): [True: 2.69k, False: 16.0k]
  ------------------
  244|  2.69k|		m_output << "ID ";
  245|  2.69k|		break;
  246|    692|	case AttDef::IDREF:
  ------------------
  |  Branch (246:2): [True: 692, False: 18.0k]
  ------------------
  247|    692|		m_output << "IDREF ";
  248|    692|		break;
  249|    894|	case AttDef::IDREFS:
  ------------------
  |  Branch (249:2): [True: 894, False: 17.8k]
  ------------------
  250|    894|		m_output << "IDREFS ";
  251|    894|		break;
  252|    333|	case AttDef::ENTITY:
  ------------------
  |  Branch (252:2): [True: 333, False: 18.4k]
  ------------------
  253|    333|		m_output << "ENTITY ";
  254|    333|		break;
  255|    361|	case AttDef::ENTITIES:
  ------------------
  |  Branch (255:2): [True: 361, False: 18.4k]
  ------------------
  256|    361|		m_output << "ENTITIES ";
  257|    361|		break;
  258|    454|	case AttDef::NMTOKEN:
  ------------------
  |  Branch (258:2): [True: 454, False: 18.3k]
  ------------------
  259|    454|		m_output << "NMTOKEN ";
  260|    454|		break;
  261|    324|	case AttDef::NMTOKENS:
  ------------------
  |  Branch (261:2): [True: 324, False: 18.4k]
  ------------------
  262|    324|		m_output << "NMTOKENS ";
  263|    324|		break;
  264|    151|	case AttDef::FUZZ:
  ------------------
  |  Branch (264:2): [True: 151, False: 18.6k]
  ------------------
  265|    151|		m_output << "FUZZ ";
  266|    151|		break;
  267|      0|	case AttDef_Type_AttDef_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (267:2): [True: 0, False: 18.7k]
  ------------------
  268|      0|	case AttDef_Type_AttDef_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (268:2): [True: 0, False: 18.7k]
  ------------------
  269|      0|		break;
  270|  18.7k|	}
  271|  18.7k|	visit(_x.def());
  272|  18.7k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_11AttListDeclE:
  275|  3.81k|{
  276|  3.81k|	m_output << "<!ATTLIST " << removeNonAscii(_x.name());
  277|  3.81k|	for (auto const& att: _x.attdefs())
  ------------------
  |  Branch (277:22): [True: 18.8k, False: 3.81k]
  ------------------
  278|  18.8k|		visit(att);
  279|  3.81k|	m_output << ">";
  280|  3.81k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_12NotationDeclE:
  283|  5.15k|{
  284|  5.15k|	m_output << "<!NOTATION " << removeNonAscii(_x.name()) << " ";
  285|  5.15k|	switch (_x.notation_oneof_case())
  ------------------
  |  Branch (285:10): [True: 0, False: 5.15k]
  ------------------
  286|  5.15k|	{
  287|  1.05k|	case NotationDecl::kExt:
  ------------------
  |  Branch (287:2): [True: 1.05k, False: 4.10k]
  ------------------
  288|  1.05k|		visit(_x.ext());
  289|  1.05k|		break;
  290|  2.72k|	case NotationDecl::kPub:
  ------------------
  |  Branch (290:2): [True: 2.72k, False: 2.42k]
  ------------------
  291|  2.72k|		m_output << "PUBLIC " << _x.pub();
  292|  2.72k|		break;
  293|    661|	case NotationDecl::kFuzz:
  ------------------
  |  Branch (293:2): [True: 661, False: 4.49k]
  ------------------
  294|    661|		m_output << "FUZZ " << _x.fuzz();
  295|    661|		break;
  296|    717|	case NotationDecl::NOTATION_ONEOF_NOT_SET:
  ------------------
  |  Branch (296:2): [True: 717, False: 4.43k]
  ------------------
  297|    717|		break;
  298|  5.15k|	}
  299|  5.15k|	m_output << ">";
  300|  5.15k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_9NDataDeclE:
  303|  1.75k|{
  304|  1.75k|	m_output << " NDATA " << _x.name();
  305|  1.75k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_9EntityDefE:
  308|  8.98k|{
  309|  8.98k|	switch (_x.entity_oneof_case())
  ------------------
  |  Branch (309:10): [True: 0, False: 8.98k]
  ------------------
  310|  8.98k|	{
  311|  4.11k|	case EntityDef::kExt:
  ------------------
  |  Branch (311:2): [True: 4.11k, False: 4.87k]
  ------------------
  312|  4.11k|		visit(_x.ext());
  313|  4.11k|		if (_x.ByteSizeLong() % 2)
  ------------------
  |  Branch (313:7): [True: 1.75k, False: 2.35k]
  ------------------
  314|  1.75k|			visit(_x.ndata());
  315|  4.11k|		break;
  316|  2.82k|	case EntityDef::kVal:
  ------------------
  |  Branch (316:2): [True: 2.82k, False: 6.16k]
  ------------------
  317|  2.82k|		visit(_x.val());
  318|  2.82k|		break;
  319|  2.04k|	case EntityDef::ENTITY_ONEOF_NOT_SET:
  ------------------
  |  Branch (319:2): [True: 2.04k, False: 6.94k]
  ------------------
  320|  2.04k|		break;
  321|  8.98k|	}
  322|  8.98k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_5PEDefE:
  325|  3.36k|{
  326|  3.36k|	switch (_x.pedef_oneof_case())
  ------------------
  |  Branch (326:10): [True: 0, False: 3.36k]
  ------------------
  327|  3.36k|	{
  328|  1.37k|	case PEDef::kVal:
  ------------------
  |  Branch (328:2): [True: 1.37k, False: 1.99k]
  ------------------
  329|  1.37k|		visit(_x.val());
  330|  1.37k|		break;
  331|    837|	case PEDef::kId:
  ------------------
  |  Branch (331:2): [True: 837, False: 2.53k]
  ------------------
  332|    837|		visit(_x.id());
  333|    837|		break;
  334|  1.16k|	case PEDef::PEDEF_ONEOF_NOT_SET:
  ------------------
  |  Branch (334:2): [True: 1.16k, False: 2.20k]
  ------------------
  335|  1.16k|		break;
  336|  3.36k|	}
  337|  3.36k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_11EntityValueE:
  340|  4.19k|{
  341|  4.19k|	if (!isValid(_x))
  ------------------
  |  Branch (341:6): [True: 68, False: 4.12k]
  ------------------
  342|     68|		return;
  343|       |
  344|  4.12k|	m_output << "\"";
  345|  4.12k|	string prefix;
  346|  4.12k|	switch (_x.type())
  ------------------
  |  Branch (346:10): [True: 0, False: 4.12k]
  ------------------
  347|  4.12k|	{
  348|  1.83k|	case EntityValue::ENTITY:
  ------------------
  |  Branch (348:2): [True: 1.83k, False: 2.28k]
  ------------------
  349|  1.83k|		prefix = "&";
  350|  1.83k|		break;
  351|  1.77k|	case EntityValue::CHAR:
  ------------------
  |  Branch (351:2): [True: 1.77k, False: 2.35k]
  ------------------
  352|  1.77k|		if (_x.ByteSizeLong() % 2)
  ------------------
  |  Branch (352:7): [True: 966, False: 804]
  ------------------
  353|    966|			prefix = "&#";
  354|    804|		else
  355|    804|			prefix = "&#x";
  356|  1.77k|		break;
  357|    221|	case EntityValue::PEREF:
  ------------------
  |  Branch (357:2): [True: 221, False: 3.90k]
  ------------------
  358|    221|		prefix = "%";
  359|    221|		break;
  360|    298|	case EntityValue::FUZZ:
  ------------------
  |  Branch (360:2): [True: 298, False: 3.82k]
  ------------------
  361|    298|		prefix = "fuzz";
  362|    298|		break;
  363|      0|	case EntityValue_Type_EntityValue_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (363:2): [True: 0, False: 4.12k]
  ------------------
  364|      0|	case EntityValue_Type_EntityValue_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (364:2): [True: 0, False: 4.12k]
  ------------------
  365|      0|		break;
  366|  4.12k|	}
  367|  4.12k|	for (auto const& ref: _x.name())
  ------------------
  |  Branch (367:22): [True: 9.01k, False: 4.12k]
  ------------------
  368|  9.01k|		m_output << prefix << ref << ";";
  369|  4.12k|	m_output << "\"";
  370|  4.12k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_10EntityDeclE:
  373|  12.4k|{
  374|  12.4k|	if (!isValid(_x))
  ------------------
  |  Branch (374:6): [True: 100, False: 12.3k]
  ------------------
  375|    100|		return;
  376|       |
  377|  12.3k|	m_output << "<!ENTITY ";
  378|  12.3k|	switch (_x.type())
  ------------------
  |  Branch (378:10): [True: 0, False: 12.3k]
  ------------------
  379|  12.3k|	{
  380|  8.98k|	case EntityDecl::GEDECL:
  ------------------
  |  Branch (380:2): [True: 8.98k, False: 3.36k]
  ------------------
  381|  8.98k|		m_output << _x.name() << " ";
  382|  8.98k|		visit(_x.ent());
  383|  8.98k|		break;
  384|  3.36k|	case EntityDecl::PEDECL:
  ------------------
  |  Branch (384:2): [True: 3.36k, False: 8.98k]
  ------------------
  385|  3.36k|		m_output << "% " << _x.name() << " ";
  386|  3.36k|		visit(_x.pedef());
  387|  3.36k|		break;
  388|      0|	case EntityDecl_Type_EntityDecl_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (388:2): [True: 0, False: 12.3k]
  ------------------
  389|      0|	case EntityDecl_Type_EntityDecl_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (389:2): [True: 0, False: 12.3k]
  ------------------
  390|      0|		break;
  391|  12.3k|	}
  392|  12.3k|	m_output << ">";
  393|  12.3k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_15ConditionalSectE:
  396|  7.06k|{
  397|  7.06k|	if (!isValid(_x))
  ------------------
  |  Branch (397:6): [True: 213, False: 6.84k]
  ------------------
  398|    213|		return;
  399|       |
  400|  6.84k|	switch (_x.type())
  ------------------
  |  Branch (400:10): [True: 0, False: 6.84k]
  ------------------
  401|  6.84k|	{
  402|  4.37k|	case ConditionalSect::INCLUDE:
  ------------------
  |  Branch (402:2): [True: 4.37k, False: 2.47k]
  ------------------
  403|  4.37k|		m_output << "<![ INCLUDE [";
  404|  4.37k|		visit(_x.ext());
  405|  4.37k|		m_output << "]]>";
  406|  4.37k|		break;
  407|    882|	case ConditionalSect::IGNORE:
  ------------------
  |  Branch (407:2): [True: 882, False: 5.96k]
  ------------------
  408|    882|		m_output << "<![ IGNORE [";
  409|    882|		for (auto const& str: _x.ignores())
  ------------------
  |  Branch (409:23): [True: 855, False: 882]
  ------------------
  410|    855|			m_output << "<![" << removeNonAscii(str) << "]]>";
  411|    882|		m_output << "]]>";
  412|    882|		break;
  413|  1.58k|	case ConditionalSect::FUZZ:
  ------------------
  |  Branch (413:2): [True: 1.58k, False: 5.26k]
  ------------------
  414|  1.58k|		m_output << "<![ FUZZ [";
  415|  1.58k|		visit(_x.ext());
  416|  1.58k|		m_output << "]]>";
  417|  1.58k|		break;
  418|      0|	case ConditionalSect_Type_ConditionalSect_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (418:2): [True: 0, False: 6.84k]
  ------------------
  419|      0|	case ConditionalSect_Type_ConditionalSect_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (419:2): [True: 0, False: 6.84k]
  ------------------
  420|      0|		break;
  421|  6.84k|	}
  422|  6.84k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_16OneExtSubsetDeclE:
  426|  33.8k|{
  427|  33.8k|	switch (_x.extsubset_oneof_case())
  ------------------
  |  Branch (427:10): [True: 0, False: 33.8k]
  ------------------
  428|  33.8k|	{
  429|  19.1k|	case OneExtSubsetDecl::kM:
  ------------------
  |  Branch (429:2): [True: 19.1k, False: 14.6k]
  ------------------
  430|  19.1k|		visit(_x.m());
  431|  19.1k|		break;
  432|  7.06k|	case OneExtSubsetDecl::kC:
  ------------------
  |  Branch (432:2): [True: 7.06k, False: 26.7k]
  ------------------
  433|  7.06k|		visit(_x.c());
  434|  7.06k|		break;
  435|  7.62k|	case OneExtSubsetDecl::EXTSUBSET_ONEOF_NOT_SET:
  ------------------
  |  Branch (435:2): [True: 7.62k, False: 26.2k]
  ------------------
  436|  7.62k|		break;
  437|  33.8k|	}
  438|  33.8k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_13ExtSubsetDeclE:
  442|  11.0k|{
  443|  11.0k|	for (auto const& decl: _x.decls())
  ------------------
  |  Branch (443:23): [True: 33.8k, False: 11.0k]
  ------------------
  444|  33.8k|		visit(decl);
  445|  11.0k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_5CDataE:
  448|  3.27k|{
  449|  3.27k|	m_output << "<![CDATA[" << removeNonAscii(_x.data()) << "]]>";
  450|  3.27k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_10MarkupDeclE:
  453|  40.3k|{
  454|  40.3k|	switch (_x.markup_oneof_case())
  ------------------
  |  Branch (454:10): [True: 0, False: 40.3k]
  ------------------
  455|  40.3k|	{
  456|  5.70k|	case MarkupDecl::kE:
  ------------------
  |  Branch (456:2): [True: 5.70k, False: 34.6k]
  ------------------
  457|  5.70k|		visit(_x.e());
  458|  5.70k|		break;
  459|  3.81k|	case MarkupDecl::kA:
  ------------------
  |  Branch (459:2): [True: 3.81k, False: 36.5k]
  ------------------
  460|  3.81k|		visit(_x.a());
  461|  3.81k|		break;
  462|  5.15k|	case MarkupDecl::kN:
  ------------------
  |  Branch (462:2): [True: 5.15k, False: 35.2k]
  ------------------
  463|  5.15k|		visit(_x.n());
  464|  5.15k|		break;
  465|  1.91k|	case MarkupDecl::kM:
  ------------------
  |  Branch (465:2): [True: 1.91k, False: 38.4k]
  ------------------
  466|  1.91k|		visit(_x.m());
  467|  1.91k|		break;
  468|  12.4k|	case MarkupDecl::kEntity:
  ------------------
  |  Branch (468:2): [True: 12.4k, False: 27.9k]
  ------------------
  469|  12.4k|		visit(_x.entity());
  470|  12.4k|		break;
  471|  5.03k|	case MarkupDecl::kExt:
  ------------------
  |  Branch (471:2): [True: 5.03k, False: 35.3k]
  ------------------
  472|  5.03k|		visit(_x.ext());
  473|  5.03k|		break;
  474|  6.31k|	case MarkupDecl::MARKUP_ONEOF_NOT_SET:
  ------------------
  |  Branch (474:2): [True: 6.31k, False: 34.0k]
  ------------------
  475|  6.31k|		break;
  476|  40.3k|	}
  477|  40.3k|}
_ZN14xmlProtoFuzzer14ProtoConverter13getPredefinedENS_10Element_IdERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  485|   391k|{
  486|   391k|	string output{};
  487|   391k|	switch (_x)
  ------------------
  |  Branch (487:10): [True: 925, False: 390k]
  ------------------
  488|   391k|	{
  489|   372k|	case Element::XIINCLUDE:
  ------------------
  |  Branch (489:2): [True: 372k, False: 19.0k]
  ------------------
  490|   374k|	case Element::XIFALLBACK:
  ------------------
  |  Branch (490:2): [True: 2.65k, False: 388k]
  ------------------
  491|   380k|	case Element::XIHREF:
  ------------------
  |  Branch (491:2): [True: 6.15k, False: 385k]
  ------------------
  492|   380k|		output = "xi:include href=\"fuzz.xml\"";
  493|   382k|	case Element::XIPARSE:
  ------------------
  |  Branch (493:2): [True: 1.66k, False: 389k]
  ------------------
  494|   382k|		output = "xi:include parse=\"xml\"";
  495|   383k|	case Element::XIXPOINTER:
  ------------------
  |  Branch (495:2): [True: 1.10k, False: 390k]
  ------------------
  496|   383k|		output = "xi:include xpointer=\"" + removeNonAscii(_prop) + "\"";
  497|   386k|	case Element::XIENCODING:
  ------------------
  |  Branch (497:2): [True: 2.78k, False: 388k]
  ------------------
  498|   386k|		output = "xi:include encoding=\"" + removeNonAscii(_prop) + "\"";
  499|   389k|	case Element::XIACCEPT:
  ------------------
  |  Branch (499:2): [True: 3.03k, False: 388k]
  ------------------
  500|   389k|		output = "xi:include accept=\"" + removeNonAscii(_prop) + "\"";
  501|   390k|	case Element::XIACCEPTLANG:
  ------------------
  |  Branch (501:2): [True: 752, False: 390k]
  ------------------
  502|   390k|		output = "xi:include accept-language=\"" + removeNonAscii(_prop) + "\"";
  503|   390k|	case Element_Id_Element_Id_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (503:2): [True: 0, False: 391k]
  ------------------
  504|   390k|	case Element_Id_Element_Id_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (504:2): [True: 0, False: 391k]
  ------------------
  505|   390k|		output = "xi:fuzz xifuzz=\"fuzz\"";
  506|   391k|	}
  507|   391k|	return output;
  508|   391k|}
_ZN14xmlProtoFuzzer14ProtoConverter6getUriENS_10Element_IdE:
  512|   391k|{
  513|   391k|	if (!Element::Id_IsValid(_x))
  ------------------
  |  Branch (513:6): [True: 925, False: 390k]
  ------------------
  514|    925|		return s_XInclude;
  515|       |
  516|   390k|	switch (_x)
  ------------------
  |  Branch (516:10): [True: 0, False: 390k]
  ------------------
  517|   390k|	{
  518|   372k|	case Element::XIINCLUDE:
  ------------------
  |  Branch (518:2): [True: 372k, False: 18.1k]
  ------------------
  519|   374k|	case Element::XIFALLBACK:
  ------------------
  |  Branch (519:2): [True: 2.65k, False: 387k]
  ------------------
  520|   380k|	case Element::XIHREF:
  ------------------
  |  Branch (520:2): [True: 6.15k, False: 384k]
  ------------------
  521|   382k|	case Element::XIPARSE:
  ------------------
  |  Branch (521:2): [True: 1.66k, False: 388k]
  ------------------
  522|   383k|	case Element::XIXPOINTER:
  ------------------
  |  Branch (522:2): [True: 1.10k, False: 389k]
  ------------------
  523|   386k|	case Element::XIENCODING:
  ------------------
  |  Branch (523:2): [True: 2.78k, False: 387k]
  ------------------
  524|   389k|	case Element::XIACCEPT:
  ------------------
  |  Branch (524:2): [True: 3.03k, False: 387k]
  ------------------
  525|   390k|	case Element::XIACCEPTLANG:
  ------------------
  |  Branch (525:2): [True: 752, False: 389k]
  ------------------
  526|   390k|	case Element_Id_Element_Id_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (526:2): [True: 0, False: 390k]
  ------------------
  527|   390k|	case Element_Id_Element_Id_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (527:2): [True: 0, False: 390k]
  ------------------
  528|   390k|		return s_XInclude;
  529|   390k|	}
  530|   390k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_7ElementE:
  533|   410k|{
  534|   410k|	if (!isValid(_x))
  ------------------
  |  Branch (534:6): [True: 77, False: 410k]
  ------------------
  535|     77|		return;
  536|       |
  537|       |	// Predefined child node
  538|   410k|	string child = {};
  539|       |	// Predefined uri for child node
  540|   410k|	string pUri = {};
  541|       |	// Element name
  542|   410k|	string name = removeNonAscii(_x.name());
  543|       |
  544|   410k|	switch (_x.type())
  ------------------
  |  Branch (544:10): [True: 0, False: 410k]
  ------------------
  545|   410k|	{
  546|   391k|	case Element::PREDEFINED:
  ------------------
  |  Branch (546:2): [True: 391k, False: 19.4k]
  ------------------
  547|   391k|		child = getPredefined(_x.id(), _x.childprop());
  548|   391k|		pUri = getUri(_x.id());
  549|   391k|		break;
  550|  19.4k|	case Element::FUZZ:
  ------------------
  |  Branch (550:2): [True: 19.4k, False: 391k]
  ------------------
  551|  19.4k|	case Element_Type_Element_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (551:2): [True: 0, False: 410k]
  ------------------
  552|  19.4k|	case Element_Type_Element_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (552:2): [True: 0, False: 410k]
  ------------------
  553|  19.4k|		break;
  554|   410k|	}
  555|       |
  556|       |	// <name k1=v1 k2=v2 k3=v3>
  557|       |	// <content>
  558|       |	// </name>
  559|       |
  560|       |	// Start name tag: Must be Ascii?
  561|   410k|	m_output << "<" << name << " ";
  562|       |
  563|       |	// Add uri to name tag
  564|   410k|	if (!pUri.empty())
  ------------------
  |  Branch (564:6): [True: 391k, False: 19.4k]
  ------------------
  565|   391k|		m_output << pUri << " ";
  566|   410k|	for (auto const& prop: _x.kv())
  ------------------
  |  Branch (566:23): [True: 30.6k, False: 410k]
  ------------------
  567|  30.6k|		visit(prop);
  568|   410k|	m_output << ">\n";
  569|       |
  570|       |	// Add attribute
  571|   410k|	if (!child.empty())
  ------------------
  |  Branch (571:6): [True: 390k, False: 20.3k]
  ------------------
  572|   390k|		m_output << "<" << child << "/>\n";
  573|       |
  574|       |	// Add content
  575|   410k|	visit(_x.content());
  576|       |
  577|       |	// Close name tag
  578|   410k|	m_output << "</" << name << ">\n";
  579|   410k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_10ExternalIdE:
  582|  14.5k|{
  583|  14.5k|	if (!isValid(_x))
  ------------------
  |  Branch (583:6): [True: 1.16k, False: 13.3k]
  ------------------
  584|  1.16k|		return;
  585|       |
  586|  13.3k|	switch (_x.type())
  ------------------
  |  Branch (586:10): [True: 0, False: 13.3k]
  ------------------
  587|  13.3k|	{
  588|  11.4k|	case ExternalId::SYSTEM:
  ------------------
  |  Branch (588:2): [True: 11.4k, False: 1.88k]
  ------------------
  589|  11.4k|		m_output << "SYSTEM " << "\"" << removeNonAscii(_x.system()) << "\"";
  590|  11.4k|		break;
  591|  1.13k|	case ExternalId::PUBLIC:
  ------------------
  |  Branch (591:2): [True: 1.13k, False: 12.2k]
  ------------------
  592|  1.13k|		m_output << "PUBLIC " << "\"" << removeNonAscii(_x.pub()) << "\""
  593|  1.13k|			<< " " << "\"" << removeNonAscii(_x.system()) << "\"";
  594|  1.13k|		break;
  595|    749|	case ExternalId::FUZZ:
  ------------------
  |  Branch (595:2): [True: 749, False: 12.6k]
  ------------------
  596|    749|		m_output << "FUZZ " << "\"" << removeNonAscii(_x.pub()) << "\"";
  597|    749|		break;
  598|      0|	case ExternalId_Type_ExternalId_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (598:2): [True: 0, False: 13.3k]
  ------------------
  599|      0|	case ExternalId_Type_ExternalId_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (599:2): [True: 0, False: 13.3k]
  ------------------
  600|      0|		break;
  601|  13.3k|	}
  602|  13.3k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_11DocTypeDeclE:
  605|  8.51k|{
  606|  8.51k|	m_output << "<!DOCTYPE " << removeNonAscii(_x.name()) << " ";
  607|  8.51k|	visit(_x.ext());
  608|  8.51k|	m_output << "[";
  609|  8.51k|	for (auto const& m: _x.mdecl())
  ------------------
  |  Branch (609:20): [True: 21.2k, False: 8.51k]
  ------------------
  610|  21.2k|		visit(m);
  611|  8.51k|	m_output << "]";
  612|  8.51k|	m_output << ">\n";
  613|  8.51k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_10VersionNumE:
  616|  8.51k|{
  617|  8.51k|	if (!isValid(_x))
  ------------------
  |  Branch (617:6): [True: 3, False: 8.51k]
  ------------------
  618|      3|		return;
  619|       |
  620|  8.51k|	switch (_x.type())
  ------------------
  |  Branch (620:10): [True: 0, False: 8.51k]
  ------------------
  621|  8.51k|	{
  622|  8.36k|	case VersionNum::STANDARD:
  ------------------
  |  Branch (622:2): [True: 8.36k, False: 144]
  ------------------
  623|  8.36k|		m_output << "\"1.0\"";
  624|  8.36k|		break;
  625|    144|	case VersionNum::FUZZ:
  ------------------
  |  Branch (625:2): [True: 144, False: 8.36k]
  ------------------
  626|    144|	case VersionNum_Type_VersionNum_Type_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (626:2): [True: 0, False: 8.51k]
  ------------------
  627|    144|	case VersionNum_Type_VersionNum_Type_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (627:2): [True: 0, False: 8.51k]
  ------------------
  628|    144|		m_output << "\"" << _x.major() << "." << _x.minor() << "\"";
  629|    144|		break;
  630|  8.51k|	}
  631|  8.51k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_9EncodingsE:
  634|  8.51k|{
  635|  8.51k|	if (!Encodings::Enc_IsValid(_x.name()))
  ------------------
  |  Branch (635:6): [True: 855, False: 7.66k]
  ------------------
  636|    855|		return;
  637|       |
  638|  7.66k|	m_output << " encoding=\"";
  639|  7.66k|	switch (_x.name())
  ------------------
  |  Branch (639:10): [True: 0, False: 7.66k]
  ------------------
  640|  7.66k|	{
  641|  6.79k|	case Encodings::BIG5:
  ------------------
  |  Branch (641:2): [True: 6.79k, False: 869]
  ------------------
  642|  6.79k|		m_output << "BIG5";
  643|  6.79k|		break;
  644|     12|	case Encodings::EUCJP:
  ------------------
  |  Branch (644:2): [True: 12, False: 7.64k]
  ------------------
  645|     12|		m_output << "EUC-JP";
  646|     12|		break;
  647|     53|	case Encodings::EUCKR:
  ------------------
  |  Branch (647:2): [True: 53, False: 7.60k]
  ------------------
  648|     53|		m_output << "EUC-KR";
  649|     53|		break;
  650|     12|	case Encodings::GB18030:
  ------------------
  |  Branch (650:2): [True: 12, False: 7.64k]
  ------------------
  651|     12|		m_output << "GB18030";
  652|     12|		break;
  653|      1|	case Encodings::ISO2022JP:
  ------------------
  |  Branch (653:2): [True: 1, False: 7.66k]
  ------------------
  654|      1|		m_output << "ISO-2022-JP";
  655|      1|		break;
  656|    123|	case Encodings::ISO2022KR:
  ------------------
  |  Branch (656:2): [True: 123, False: 7.53k]
  ------------------
  657|    123|		m_output << "ISO-2022-KR";
  658|    123|		break;
  659|     67|	case Encodings::ISO88591:
  ------------------
  |  Branch (659:2): [True: 67, False: 7.59k]
  ------------------
  660|     67|		m_output << "ISO-8859-1";
  661|     67|		break;
  662|     10|	case Encodings::ISO88592:
  ------------------
  |  Branch (662:2): [True: 10, False: 7.65k]
  ------------------
  663|     10|		m_output << "ISO-8859-2";
  664|     10|		break;
  665|     12|	case Encodings::ISO88593:
  ------------------
  |  Branch (665:2): [True: 12, False: 7.64k]
  ------------------
  666|     12|		m_output << "ISO-8859-3";
  667|     12|		break;
  668|     10|	case Encodings::ISO88594:
  ------------------
  |  Branch (668:2): [True: 10, False: 7.65k]
  ------------------
  669|     10|		m_output << "ISO-8859-4";
  670|     10|		break;
  671|      8|	case Encodings::ISO88595:
  ------------------
  |  Branch (671:2): [True: 8, False: 7.65k]
  ------------------
  672|      8|		m_output << "ISO-8859-5";
  673|      8|		break;
  674|      4|	case Encodings::ISO88596:
  ------------------
  |  Branch (674:2): [True: 4, False: 7.65k]
  ------------------
  675|      4|		m_output << "ISO-8859-6";
  676|      4|		break;
  677|      4|	case Encodings::ISO88597:
  ------------------
  |  Branch (677:2): [True: 4, False: 7.65k]
  ------------------
  678|      4|		m_output << "ISO-8859-7";
  679|      4|		break;
  680|      3|	case Encodings::ISO88598:
  ------------------
  |  Branch (680:2): [True: 3, False: 7.65k]
  ------------------
  681|      3|		m_output << "ISO-8859-8";
  682|      3|		break;
  683|     14|	case Encodings::ISO88599:
  ------------------
  |  Branch (683:2): [True: 14, False: 7.64k]
  ------------------
  684|     14|		m_output << "ISO-8859-9";
  685|     14|		break;
  686|    113|	case Encodings::SHIFTJIS:
  ------------------
  |  Branch (686:2): [True: 113, False: 7.54k]
  ------------------
  687|    113|		m_output << "SHIFT_JIS";
  688|    113|		break;
  689|     12|	case Encodings::TIS620:
  ------------------
  |  Branch (689:2): [True: 12, False: 7.64k]
  ------------------
  690|     12|		m_output << "TIS-620";
  691|     12|		break;
  692|     74|	case Encodings::USASCII:
  ------------------
  |  Branch (692:2): [True: 74, False: 7.58k]
  ------------------
  693|     74|		m_output << "US-ASCII";
  694|     74|		break;
  695|     82|	case Encodings::UTF8:
  ------------------
  |  Branch (695:2): [True: 82, False: 7.57k]
  ------------------
  696|     82|		m_output << "UTF-8";
  697|     82|		break;
  698|     23|	case Encodings::UTF16:
  ------------------
  |  Branch (698:2): [True: 23, False: 7.63k]
  ------------------
  699|     23|		m_output << "UTF-16";
  700|     23|		break;
  701|     14|	case Encodings::UTF16BE:
  ------------------
  |  Branch (701:2): [True: 14, False: 7.64k]
  ------------------
  702|     14|		m_output << "UTF-16BE";
  703|     14|		break;
  704|     11|	case Encodings::UTF16LE:
  ------------------
  |  Branch (704:2): [True: 11, False: 7.65k]
  ------------------
  705|     11|		m_output << "UTF-16LE";
  706|     11|		break;
  707|     63|	case Encodings::WINDOWS31J:
  ------------------
  |  Branch (707:2): [True: 63, False: 7.59k]
  ------------------
  708|     63|		m_output << "WINDOWS-31J";
  709|     63|		break;
  710|      6|	case Encodings::WINDOWS1255:
  ------------------
  |  Branch (710:2): [True: 6, False: 7.65k]
  ------------------
  711|      6|		m_output << "WINDOWS-1255";
  712|      6|		break;
  713|      4|	case Encodings::WINDOWS1256:
  ------------------
  |  Branch (713:2): [True: 4, False: 7.65k]
  ------------------
  714|      4|		m_output << "WINDOWS-1256";
  715|      4|		break;
  716|    134|	case Encodings::FUZZ:
  ------------------
  |  Branch (716:2): [True: 134, False: 7.52k]
  ------------------
  717|    134|		m_output << removeNonAscii(_x.fuzz());
  718|    134|		break;
  719|      0|	case Encodings_Enc_Encodings_Enc_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (719:2): [True: 0, False: 7.66k]
  ------------------
  720|      0|	case Encodings_Enc_Encodings_Enc_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (720:2): [True: 0, False: 7.66k]
  ------------------
  721|      0|		break;
  722|  7.66k|	}
  723|  7.66k|	m_output << "\"";
  724|  7.66k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_14XmlDeclarationE:
  727|  8.51k|{
  728|  8.51k|	m_output << R"(<?xml version=)";
  729|  8.51k|	visit(_x.ver());
  730|  8.51k|	visit(_x.enc());
  731|  8.51k|	switch (_x.standalone())
  732|  8.51k|	{
  733|  8.20k|	case XmlDeclaration::YES:
  ------------------
  |  Branch (733:2): [True: 8.20k, False: 315]
  ------------------
  734|  8.20k|		m_output << " standalone=\'yes\'";
  735|  8.20k|		break;
  736|    288|	case XmlDeclaration::NO:
  ------------------
  |  Branch (736:2): [True: 288, False: 8.22k]
  ------------------
  737|    288|		m_output << " standalone=\'no\'";
  738|    288|		break;
  739|      0|	case XmlDeclaration_Standalone_XmlDeclaration_Standalone_INT_MIN_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (739:2): [True: 0, False: 8.51k]
  ------------------
  740|      0|	case XmlDeclaration_Standalone_XmlDeclaration_Standalone_INT_MAX_SENTINEL_DO_NOT_USE_:
  ------------------
  |  Branch (740:2): [True: 0, False: 8.51k]
  ------------------
  741|     27|	default:
  ------------------
  |  Branch (741:2): [True: 27, False: 8.48k]
  ------------------
  742|     27|		break;
  743|  8.51k|	}
  744|  8.51k|	m_output << "?>\n";
  745|  8.51k|}
_ZN14xmlProtoFuzzer14ProtoConverter5visitERKNS_11XmlDocumentE:
  748|  8.51k|{
  749|  8.51k|	visit(_x.p());
  750|  8.51k|	for (auto const& element: _x.e())
  ------------------
  |  Branch (750:26): [True: 404k, False: 8.51k]
  ------------------
  751|   404k|		visit(element);
  752|  8.51k|}
_ZN14xmlProtoFuzzer14ProtoConverter13protoToStringERKNS_11XmlDocumentE:
  755|  8.51k|{
  756|  8.51k|	visit(_x);
  757|  8.51k|	return m_output.str();
  758|  8.51k|}
xmlProtoConverter.cpp:_ZZN14xmlProtoFuzzer14ProtoConverter14removeNonAsciiERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENK3$_0clEc:
   27|  26.1M|	asciiStr.erase(remove_if(asciiStr.begin(), asciiStr.end(), [=](char c) -> bool {
   28|  26.1M|                        return !(std::isalpha(c) || std::isdigit(c));
  ------------------
  |  Branch (28:34): [True: 22.2M, False: 3.85M]
  |  Branch (28:53): [True: 1.16M, False: 2.68M]
  ------------------
   29|  26.1M|                }), asciiStr.end());

_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_8AttValueEEEbRKT_:
   93|  3.16k|	bool isValid(T const& messageType) {
   94|  3.16k|		return T::Type_IsValid(messageType.type());
   95|  3.16k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_11DefaultDeclEEEbRKT_:
   93|  18.7k|	bool isValid(T const& messageType) {
   94|  18.7k|		return T::Type_IsValid(messageType.type());
   95|  18.7k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_6AttDefEEEbRKT_:
   93|  18.8k|	bool isValid(T const& messageType) {
   94|  18.8k|		return T::Type_IsValid(messageType.type());
   95|  18.8k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_11EntityValueEEEbRKT_:
   93|  4.19k|	bool isValid(T const& messageType) {
   94|  4.19k|		return T::Type_IsValid(messageType.type());
   95|  4.19k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_10EntityDeclEEEbRKT_:
   93|  12.4k|	bool isValid(T const& messageType) {
   94|  12.4k|		return T::Type_IsValid(messageType.type());
   95|  12.4k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_15ConditionalSectEEEbRKT_:
   93|  7.06k|	bool isValid(T const& messageType) {
   94|  7.06k|		return T::Type_IsValid(messageType.type());
   95|  7.06k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_7ElementEEEbRKT_:
   93|   410k|	bool isValid(T const& messageType) {
   94|   410k|		return T::Type_IsValid(messageType.type());
   95|   410k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_10ExternalIdEEEbRKT_:
   93|  14.5k|	bool isValid(T const& messageType) {
   94|  14.5k|		return T::Type_IsValid(messageType.type());
   95|  14.5k|	}
_ZN14xmlProtoFuzzer14ProtoConverter7isValidINS_10VersionNumEEEbRKT_:
   93|  8.51k|	bool isValid(T const& messageType) {
   94|  8.51k|		return T::Type_IsValid(messageType.type());
   95|  8.51k|	}
_ZN14xmlProtoFuzzer14ProtoConverterC2Ev:
   27|  8.51k|	ProtoConverter() = default;