Names like __u32 do not pollute the POSIX namespace, but the Linux kernel uses exactly the same names.
On some Linux architectures the kernel definitions are different, e.g. http://tracker.crosswire.org/browse/API-178 All relevant compilers should now support C++ 11, but please double-check that this change works on all non-gcc compilers you support. --- CMakeLists.txt | 5 +- configure.ac | 3 +- examples/cmdline/search.cpp | 4 +- include/rawstr.h | 5 +- include/rawstr4.h | 5 +- include/stringmgr.h | 9 +- include/swkey.h | 3 +- include/sysdata.h | 61 +- include/treekeyidx.h | 11 +- include/utilstr.h | 7 +- include/xzcomprs.h | 3 +- m4/ax_cxx_compile_stdcxx.m4 | 951 ++++++++++++++++++ src/keys/treekeyidx.cpp | 37 +- src/keys/versekey.cpp | 17 +- src/mgr/stringmgr.cpp | 25 +- src/modules/comments/rawfiles/rawfiles.cpp | 5 +- src/modules/common/entriesblk.cpp | 21 +- src/modules/common/rawstr.cpp | 37 +- src/modules/common/rawstr4.cpp | 39 +- src/modules/common/rawverse.cpp | 19 +- src/modules/common/rawverse4.cpp | 21 +- src/modules/common/zstr.cpp | 73 +- src/modules/common/zverse.cpp | 49 +- src/modules/common/zverse4.cpp | 51 +- src/modules/filters/rtfhtml.cpp | 5 +- src/modules/filters/utf8greekaccents.cpp | 7 +- src/modules/filters/utf8utf16.cpp | 17 +- src/modules/genbook/rawgenbook/rawgenbook.cpp | 11 +- src/modules/lexdict/rawld/rawld.cpp | 10 +- src/modules/lexdict/rawld4/rawld4.cpp | 10 +- src/modules/swmodule.cpp | 5 +- tests/filtertest.cpp | 3 +- tests/utf8norm.cpp | 3 +- 33 files changed, 1248 insertions(+), 284 deletions(-) create mode 100644 m4/ax_cxx_compile_stdcxx.m4 diff --git a/CMakeLists.txt b/CMakeLists.txt index 1aa66701..bbb4d212 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ # all posterity and eternity, wherever such transfer is possible. Where it is # not, then this file is released under the GPLv2 by myself. PROJECT(libsword CXX C) -CMAKE_MINIMUM_REQUIRED(VERSION 2.6.0) +CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0) SET(SWORD_VERSION 1.8.900) # Make sure it's an out-of-stream build @@ -155,6 +155,9 @@ ENDIF(BUILDING_SHARED) #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}" or "$ENV{CFLAGS}" or "" ) #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" or "$ENV{CXXFLAGS}" or "" ) +SET(CMAKE_CXX_STANDARD 11) +SET(CMAKE_CXX_STANDARD_REQUIRED ON) + IF(SWORD_ENABLE_WARNINGS STREQUAL "Yes") SET(CMAKE_C_FLAGS "-Werror ${CMAKE_C_FLAGS}") SET(CMAKE_CXX_FLAGS "-Werror ${CMAKE_CXX_FLAGS}") diff --git a/configure.ac b/configure.ac index 315bafda..cd587b41 100644 --- a/configure.ac +++ b/configure.ac @@ -37,6 +37,7 @@ CXXFLAGS=" $CXXFLAGS" AC_LANG(C++) AC_PROG_CC AC_PROG_CXX +AX_CXX_COMPILE_STDCXX(11) AC_PROG_INSTALL AC_LIBTOOL_WIN32_DLL AC_PROG_LIBTOOL @@ -302,7 +303,7 @@ else fi if test x$with_cxx11regex = xyes; then - AM_CXXFLAGS="$AM_CXXFLAGS -DUSECXX11REGEX -std=c++11" + AM_CXXFLAGS="$AM_CXXFLAGS -DUSECXX11REGEX" fi # --------------------------------------------------------------------- diff --git a/examples/cmdline/search.cpp b/examples/cmdline/search.cpp index 5fd9e78c..3a54aafb 100644 --- a/examples/cmdline/search.cpp +++ b/examples/cmdline/search.cpp @@ -24,6 +24,8 @@ * */ +#include <cstdint> + #include <stdio.h> #include <rawtext.h> #include <swmgr.h> @@ -134,7 +136,7 @@ int main(int argc, char **argv) SWKey *k = listKey.getElement(); std::cout << k->getRangeText(); // std::cout << (const char *)listKey; - if (k->userData) std::cout << " : " << (__u64)k->userData << "%"; + if (k->userData) std::cout << " : " << (uint64_t)k->userData << "%"; std::cout << std::endl; } diff --git a/include/rawstr.h b/include/rawstr.h index d25ebc37..cdd05c2c 100644 --- a/include/rawstr.h +++ b/include/rawstr.h @@ -26,6 +26,7 @@ #ifndef RAWSTR_H #define RAWSTR_H +#include <cstdint> #include <defs.h> #include <sysdata.h> @@ -54,8 +55,8 @@ public: virtual ~RawStr(); void getIDXBuf(long ioffset, char **buf) const; void getIDXBufDat(long ioffset, char **buf) const; - signed char findOffset(const char *key, __u32 *start, __u16 *size, long away = 0, __u32 *idxoff = 0) const; - void readText(__u32 start, __u16 *size, char **idxbuf, SWBuf &buf) const; + signed char findOffset(const char *key, uint32_t *start, uint16_t *size, long away = 0, uint32_t *idxoff = 0) const; + void readText(uint32_t start, uint16_t *size, char **idxbuf, SWBuf &buf) const; static signed char createModule(const char *path); }; diff --git a/include/rawstr4.h b/include/rawstr4.h index 0277a25a..36bb0a74 100644 --- a/include/rawstr4.h +++ b/include/rawstr4.h @@ -26,6 +26,7 @@ #ifndef RAWSTR4_H #define RAWSTR4_H +#include <cstdint> #include <defs.h> #include <sysdata.h> @@ -53,8 +54,8 @@ public: virtual ~RawStr4(); void getIDXBuf(long ioffset, char **buf) const; void getIDXBufDat(long ioffset, char **buf) const; - signed char findOffset(const char *key, __u32 *start, __u32 *size, long away = 0, __u32 *idxoff = 0) const; - void readText(__u32 start, __u32 *size, char **idxbuf, SWBuf &buf) const; + signed char findOffset(const char *key, uint32_t *start, uint32_t *size, long away = 0, uint32_t *idxoff = 0) const; + void readText(uint32_t start, uint32_t *size, char **idxbuf, SWBuf &buf) const; static signed char createModule(const char *path); }; diff --git a/include/stringmgr.h b/include/stringmgr.h index 237ba148..8344c42f 100644 --- a/include/stringmgr.h +++ b/include/stringmgr.h @@ -25,6 +25,7 @@ #ifndef STRINGMGR_H #define STRINGMGR_H +#include <cstdint> #include <defs.h> #include <swbuf.h> #include <utilstr.h> @@ -70,10 +71,10 @@ public: */ virtual char *lowerUTF8(char *text, unsigned int max = 0) const; - virtual bool isUpper(__u32 character) const; - virtual bool isLower(__u32 character) const; - virtual bool isDigit(__u32 character) const; - virtual bool isAlpha(__u32 character) const; + virtual bool isUpper(uint32_t character) const; + virtual bool isLower(uint32_t character) const; + virtual bool isDigit(uint32_t character) const; + virtual bool isAlpha(uint32_t character) const; /** Converts the param to an uppercase latin1 string * @param text The text encoded in latin1 which should be turned into an upper case string diff --git a/include/swkey.h b/include/swkey.h index 52e94414..4a61f69e 100644 --- a/include/swkey.h +++ b/include/swkey.h @@ -27,6 +27,7 @@ #include <swobject.h> +#include <cstdint> #include <defs.h> #include <sysdata.h> #include <utilstr.h> @@ -114,7 +115,7 @@ protected: public: // misc storage for whatever - __u64 userData; + uint64_t userData; /** initializes instance of SWKey from a string * All keys can be reduced to a string representation which should be able diff --git a/include/sysdata.h b/include/sysdata.h index f979f29f..ae7fdbd5 100644 --- a/include/sysdata.h +++ b/include/sysdata.h @@ -22,64 +22,41 @@ #ifndef SIZEDTYPES_H #define SIZEDTYPES_H -/* - * __xx is ok: it doesn't pollute the POSIX namespace. Use these in the - * header files exported to user space - */ + #ifdef USE_AUTOTOOLS #include "config.h" #endif - -typedef signed char __s8; -typedef unsigned char __u8; - -typedef signed short __s16; -typedef unsigned short __u16; - -typedef signed int __s32; -typedef unsigned int __u32; - -#ifdef OS_ANDROID -#elif defined(__GNUC__) -__extension__ typedef __signed__ long long __s64; -__extension__ typedef unsigned long long __u64; -#elif defined(__BORLANDC__) -typedef signed __int64 __s64; -typedef unsigned __int64 __u64; -#else -typedef signed long long __s64; -typedef unsigned long long __u64; -#endif +#include <cstdint> #undef __swswap16 #undef __swswap32 #undef __swswap64 #define __swswap16(x) \ - ((__u16)( \ - (((__u16)(x) & (__u16)0x00ffU) << 8) | \ - (((__u16)(x) & (__u16)0xff00U) >> 8) )) + ((uint16_t)( \ + (((uint16_t)(x) & (uint16_t)0x00ffU) << 8) | \ + (((uint16_t)(x) & (uint16_t)0xff00U) >> 8) )) #define __swswap32(x) \ - ((__u32)( \ - (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \ - (((__u32)(x) & (__u32)0x0000ff00UL) << 8) | \ - (((__u32)(x) & (__u32)0x00ff0000UL) >> 8) | \ - (((__u32)(x) & (__u32)0xff000000UL) >> 24) )) + ((uint32_t)( \ + (((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) | \ + (((uint32_t)(x) & (uint32_t)0x0000ff00UL) << 8) | \ + (((uint32_t)(x) & (uint32_t)0x00ff0000UL) >> 8) | \ + (((uint32_t)(x) & (uint32_t)0xff000000UL) >> 24) )) #define __swswap64(x) \ - ((__u64)( \ - (__u64)(((__u64)(x) & (__u64)0x00000000000000ffULL) << 56) | \ - (__u64)(((__u64)(x) & (__u64)0x000000000000ff00ULL) << 40) | \ - (__u64)(((__u64)(x) & (__u64)0x0000000000ff0000ULL) << 24) | \ - (__u64)(((__u64)(x) & (__u64)0x00000000ff000000ULL) << 8) | \ - (__u64)(((__u64)(x) & (__u64)0x000000ff00000000ULL) >> 8) | \ - (__u64)(((__u64)(x) & (__u64)0x0000ff0000000000ULL) >> 24) | \ - (__u64)(((__u64)(x) & (__u64)0x00ff000000000000ULL) >> 40) | \ - (__u64)(((__u64)(x) & (__u64)0xff00000000000000ULL) >> 56) )) + ((uint64_t)( \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x00000000000000ffULL) << 56) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x000000000000ff00ULL) << 40) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x0000000000ff0000ULL) << 24) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x00000000ff000000ULL) << 8) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x000000ff00000000ULL) >> 8) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x0000ff0000000000ULL) >> 24) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0x00ff000000000000ULL) >> 40) | \ + (uint64_t)(((uint64_t)(x) & (uint64_t)0xff00000000000000ULL) >> 56) )) diff --git a/include/treekeyidx.h b/include/treekeyidx.h index 331b7e83..f89ae6e1 100644 --- a/include/treekeyidx.h +++ b/include/treekeyidx.h @@ -24,6 +24,7 @@ #ifndef TREEKEYIDX_H #define TREEKEYIDX_H +#include <cstdint> #include <treekey.h> #include <sysdata.h> @@ -42,12 +43,12 @@ class SWDLLEXPORT TreeKeyIdx : public TreeKey { TreeNode(); ~TreeNode(); void clear(); - __s32 offset; - __s32 parent; - __s32 next; - __s32 firstChild; + int32_t offset; + int32_t parent; + int32_t next; + int32_t firstChild; char *name; - __u16 dsize; + uint16_t dsize; char *userData; } currentNode; diff --git a/include/utilstr.h b/include/utilstr.h index 77ca5b16..c573b6aa 100644 --- a/include/utilstr.h +++ b/include/utilstr.h @@ -23,6 +23,7 @@ #ifndef UTILSTR_H #define UTILSTR_H +#include <cstdint> #include <defs.h> #include <sysdata.h> #include <swbuf.h> @@ -85,8 +86,8 @@ extern const unsigned char SW_tolower_array[256]; * unicode codepoint value (0 with buf incremented is invalid UTF8 byte */ -inline __u32 getUniCharFromUTF8(const unsigned char **buf, bool skipValidation = false) { - __u32 ch = 0; +inline uint32_t getUniCharFromUTF8(const unsigned char **buf, bool skipValidation = false) { + uint32_t ch = 0; //case: We're at the end if (!(**buf)) { @@ -162,7 +163,7 @@ inline __u32 getUniCharFromUTF8(const unsigned char **buf, bool skipValidation = * to work with */ -inline SWBuf *getUTF8FromUniChar(__u32 uchar, SWBuf *appendTo) { +inline SWBuf *getUTF8FromUniChar(uint32_t uchar, SWBuf *appendTo) { unsigned long base = appendTo->size(); // This would be out of Unicode bounds diff --git a/include/xzcomprs.h b/include/xzcomprs.h index f3fe42b2..9568c90c 100644 --- a/include/xzcomprs.h +++ b/include/xzcomprs.h @@ -26,6 +26,7 @@ #include <swcomprs.h> +#include <cstdint> #include <defs.h> #include <sysdata.h> @@ -42,7 +43,7 @@ public: virtual void Decode(void); virtual void setLevel(int l); private: - __u64 memlimit; // memory usage limit during decompression + uint64_t memlimit; // memory usage limit during decompression }; SWORD_NAMESPACE_END diff --git a/m4/ax_cxx_compile_stdcxx.m4 b/m4/ax_cxx_compile_stdcxx.m4 new file mode 100644 index 00000000..43087b2e --- /dev/null +++ b/m4/ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,951 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) +# +# DESCRIPTION +# +# Check for baseline language coverage in the compiler for the specified +# version of the C++ standard. If necessary, add switches to CXX and +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) +# or '14' (for the C++14 standard). +# +# The second argument, if specified, indicates whether you insist on an +# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. +# -std=c++11). If neither is specified, you get whatever works, with +# preference for an extended mode. +# +# The third argument, if specified 'mandatory' or if left unspecified, +# indicates that baseline support for the specified C++ standard is +# required and that the macro should error out if no mode with that +# support is found. If specified 'optional', then configuration proceeds +# regardless, after defining HAVE_CXX${VERSION} if and only if a +# supporting mode is found. +# +# LICENSE +# +# Copyright (c) 2008 Benjamin Kosnik <b...@redhat.com> +# Copyright (c) 2012 Zack Weinberg <za...@panix.com> +# Copyright (c) 2013 Roy Stogner <royst...@ices.utexas.edu> +# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <soko...@google.com> +# Copyright (c) 2015 Paul Norman <penor...@mac.com> +# Copyright (c) 2015 Moritz Klammler <mor...@klammler.eu> +# Copyright (c) 2016, 2018 Krzesimir Nowak <qdl...@gmail.com> +# Copyright (c) 2019 Enji Cooper <yaneurab...@gmail.com> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 11 + +dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro +dnl (serial version number 13). + +AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], + [$1], [14], [ax_cxx_compile_alternatives="14 1y"], + [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], + [$2], [noext], [], + [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], + [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], + [$3], [optional], [ax_cxx_compile_cxx$1_required=false], + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + switch="-std=gnu++${alternative}" + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + + m4_if([$2], [ext], [], [dnl + if test x$ac_success = xno; then + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + if test x$ac_success = xyes; then + break + fi + done + fi]) + AC_LANG_POP([C++]) + if test x$ax_cxx_compile_cxx$1_required = xtrue; then + if test x$ac_success = xno; then + AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) + fi + fi + if test x$ac_success = xno; then + HAVE_CXX$1=0 + AC_MSG_NOTICE([No compiler with C++$1 support was found]) + else + HAVE_CXX$1=1 + AC_DEFINE(HAVE_CXX$1,1, + [define if the compiler supports basic C++$1 syntax]) + fi + AC_SUBST(HAVE_CXX$1) +]) + + +dnl Test body for checking C++11 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +) + + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +) + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +) + +dnl Tests for new features in C++11 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ + +// If the compiler admits that it is not ready for C++11, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201103L + +#error "This is not a C++11 compiler" + +#else + +namespace cxx11 +{ + + namespace test_static_assert + { + + template <typename T> + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + } + + namespace test_final_override + { + + struct Base + { + virtual ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + virtual void f() override {} + }; + + } + + namespace test_double_right_angle_brackets + { + + template < typename T > + struct check {}; + + typedef check<void> single_type; + typedef check<check<void>> double_type; + typedef check<check<check<void>>> triple_type; + typedef check<check<check<check<void>>>> quadruple_type; + + } + + namespace test_decltype + { + + int + f() + { + int a = 1; + decltype(a) b = 2; + return a + b; + } + + } + + namespace test_type_deduction + { + + template < typename T1, typename T2 > + struct is_same + { + static const bool value = false; + }; + + template < typename T > + struct is_same<T, T> + { + static const bool value = true; + }; + + template < typename T1, typename T2 > + auto + add(T1 a1, T2 a2) -> decltype(a1 + a2) + { + return a1 + a2; + } + + int + test(const int c, volatile int v) + { + static_assert(is_same<int, decltype(0)>::value == true, ""); + static_assert(is_same<int, decltype(c)>::value == false, ""); + static_assert(is_same<int, decltype(v)>::value == false, ""); + auto ac = c; + auto av = v; + auto sumi = ac + av + 'x'; + auto sumf = ac + av + 1.0; + static_assert(is_same<int, decltype(ac)>::value == true, ""); + static_assert(is_same<int, decltype(av)>::value == true, ""); + static_assert(is_same<int, decltype(sumi)>::value == true, ""); + static_assert(is_same<int, decltype(sumf)>::value == false, ""); + static_assert(is_same<int, decltype(add(c, v))>::value == true, ""); + return (sumf > 0.0) ? sumi : add(c, v); + } + + } + + namespace test_noexcept + { + + int f() { return 0; } + int g() noexcept { return 0; } + + static_assert(noexcept(f()) == false, ""); + static_assert(noexcept(g()) == true, ""); + + } + + namespace test_constexpr + { + + template < typename CharT > + unsigned long constexpr + strlen_c_r(const CharT *const s, const unsigned long acc) noexcept + { + return *s ? strlen_c_r(s + 1, acc + 1) : acc; + } + + template < typename CharT > + unsigned long constexpr + strlen_c(const CharT *const s) noexcept + { + return strlen_c_r(s, 0UL); + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("1") == 1UL, ""); + static_assert(strlen_c("example") == 7UL, ""); + static_assert(strlen_c("another\0example") == 7UL, ""); + + } + + namespace test_rvalue_references + { + + template < int N > + struct answer + { + static constexpr int value = N; + }; + + answer<1> f(int&) { return answer<1>(); } + answer<2> f(const int&) { return answer<2>(); } + answer<3> f(int&&) { return answer<3>(); } + + void + test() + { + int i = 0; + const int c = 0; + static_assert(decltype(f(i))::value == 1, ""); + static_assert(decltype(f(c))::value == 2, ""); + static_assert(decltype(f(0))::value == 3, ""); + } + + } + + namespace test_uniform_initialization + { + + struct test + { + static const int zero {}; + static const int one {1}; + }; + + static_assert(test::zero == 0, ""); + static_assert(test::one == 1, ""); + + } + + namespace test_lambdas + { + + void + test1() + { + auto lambda1 = [](){}; + auto lambda2 = lambda1; + lambda1(); + lambda2(); + } + + int + test2() + { + auto a = [](int i, int j){ return i + j; }(1, 2); + auto b = []() -> int { return '0'; }(); + auto c = [=](){ return a + b; }(); + auto d = [&](){ return c; }(); + auto e = [a, &b](int x) mutable { + const auto identity = [](int y){ return y; }; + for (auto i = 0; i < a; ++i) + a += b--; + return x + identity(a + b); + }(0); + return a + b + c + d + e; + } + + int + test3() + { + const auto nullary = [](){ return 0; }; + const auto unary = [](int x){ return x; }; + using nullary_t = decltype(nullary); + using unary_t = decltype(unary); + const auto higher1st = [](nullary_t f){ return f(); }; + const auto higher2nd = [unary](nullary_t f1){ + return [unary, f1](unary_t f2){ return f2(unary(f1())); }; + }; + return higher1st(nullary) + higher2nd(nullary)(unary); + } + + } + + namespace test_variadic_templates + { + + template <int...> + struct sum; + + template <int N0, int... N1toN> + struct sum<N0, N1toN...> + { + static constexpr auto value = N0 + sum<N1toN...>::value; + }; + + template <> + struct sum<> + { + static constexpr auto value = 0; + }; + + static_assert(sum<>::value == 0, ""); + static_assert(sum<1>::value == 1, ""); + static_assert(sum<23>::value == 23, ""); + static_assert(sum<1, 2>::value == 3, ""); + static_assert(sum<5, 5, 11>::value == 21, ""); + static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); + + } + + // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae + // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function + // because of this. + namespace test_template_alias_sfinae + { + + struct foo {}; + + template<typename T> + using member = typename T::member_type; + + template<typename T> + void func(...) {} + + template<typename T> + void func(member<T>*) {} + + void test(); + + void test() { func<foo>(0); } + + } + +} // namespace cxx11 + +#endif // __cplusplus >= 201103L + +]]) + + +dnl Tests for new features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ + +// If the compiler admits that it is not ready for C++14, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201402L + +#error "This is not a C++14 compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_binary_literals + { + + constexpr auto ivii = 0b0000000000101010; + static_assert(ivii == 42, "wrong value"); + + } + + namespace test_generalized_constexpr + { + + template < typename CharT > + constexpr unsigned long + strlen_c(const CharT *const s) noexcept + { + auto length = 0UL; + for (auto p = s; *p; ++p) + ++length; + return length; + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("x") == 1UL, ""); + static_assert(strlen_c("test") == 4UL, ""); + static_assert(strlen_c("another\0test") == 7UL, ""); + + } + + namespace test_lambda_init_capture + { + + int + test() + { + auto x = 0; + const auto lambda1 = [a = x](int b){ return a + b; }; + const auto lambda2 = [a = lambda1(x)](){ return a; }; + return lambda2(); + } + + } + + namespace test_digit_separators + { + + constexpr auto ten_million = 100'000'000; + static_assert(ten_million == 100000000, ""); + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same<T, T> + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same<int, decltype(f(x))>::value, ""); + static_assert(is_same<int&, decltype(g(x))>::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif // __cplusplus >= 201402L + +]]) + + +dnl Tests for new features in C++17 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ + +// If the compiler admits that it is not ready for C++17, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201703L + +#error "This is not a C++17 compiler" + +#else + +#include <initializer_list> +#include <utility> +#include <type_traits> + +namespace cxx17 +{ + + namespace test_constexpr_lambdas + { + + constexpr int foo = [](){return 42;}(); + + } + + namespace test::nested_namespace::definitions + { + + } + + namespace test_fold_expression + { + + template<typename... Args> + int multiply(Args... args) + { + return (args * ... * 1); + } + + template<typename... Args> + bool all(Args... args) + { + return (args && ...); + } + + } + + namespace test_extended_static_assert + { + + static_assert (true); + + } + + namespace test_auto_brace_init_list + { + + auto foo = {5}; + auto bar {5}; + + static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value); + static_assert(std::is_same<int, decltype(bar)>::value); + } + + namespace test_typename_in_template_template_parameter + { + + template<template<typename> typename X> struct D; + + } + + namespace test_fallthrough_nodiscard_maybe_unused_attributes + { + + int f1() + { + return 42; + } + + [[nodiscard]] int f2() + { + [[maybe_unused]] auto unused = f1(); + + switch (f1()) + { + case 17: + f1(); + [[fallthrough]]; + case 42: + f1(); + } + return f1(); + } + + } + + namespace test_extended_aggregate_initialization + { + + struct base1 + { + int b1, b2 = 42; + }; + + struct base2 + { + base2() { + b3 = 42; + } + int b3; + }; + + struct derived : base1, base2 + { + int d; + }; + + derived d1 {{1, 2}, {}, 4}; // full initialization + derived d2 {{}, {}, 4}; // value-initialized bases + + } + + namespace test_general_range_based_for_loop + { + + struct iter + { + int i; + + int& operator* () + { + return i; + } + + const int& operator* () const + { + return i; + } + + iter& operator++() + { + ++i; + return *this; + } + }; + + struct sentinel + { + int i; + }; + + bool operator== (const iter& i, const sentinel& s) + { + return i.i == s.i; + } + + bool operator!= (const iter& i, const sentinel& s) + { + return !(i == s); + } + + struct range + { + iter begin() const + { + return {0}; + } + + sentinel end() const + { + return {5}; + } + }; + + void f() + { + range r {}; + + for (auto i : r) + { + [[maybe_unused]] auto v = i; + } + } + + } + + namespace test_lambda_capture_asterisk_this_by_value + { + + struct t + { + int i; + int foo() + { + return [*this]() + { + return i; + }(); + } + }; + + } + + namespace test_enum_class_construction + { + + enum class byte : unsigned char + {}; + + byte foo {42}; + + } + + namespace test_constexpr_if + { + + template <bool cond> + int f () + { + if constexpr(cond) + { + return 13; + } + else + { + return 42; + } + } + + } + + namespace test_selection_statement_with_initializer + { + + int f() + { + return 13; + } + + int f2() + { + if (auto i = f(); i > 0) + { + return 3; + } + + switch (auto i = f(); i + 4) + { + case 17: + return 2; + + default: + return 1; + } + } + + } + + namespace test_template_argument_deduction_for_class_templates + { + + template <typename T1, typename T2> + struct pair + { + pair (T1 p1, T2 p2) + : m1 {p1}, + m2 {p2} + {} + + T1 m1; + T2 m2; + }; + + void f() + { + [[maybe_unused]] auto p = pair{13, 42u}; + } + + } + + namespace test_non_type_auto_template_parameters + { + + template <auto n> + struct B + {}; + + B<5> b1; + B<'a'> b2; + + } + + namespace test_structured_bindings + { + + int arr[2] = { 1, 2 }; + std::pair<int, int> pr = { 1, 2 }; + + auto f1() -> int(&)[2] + { + return arr; + } + + auto f2() -> std::pair<int, int>& + { + return pr; + } + + struct S + { + int x1 : 2; + volatile double y1; + }; + + S f3() + { + return {}; + } + + auto [ x1, y1 ] = f1(); + auto& [ xr1, yr1 ] = f1(); + auto [ x2, y2 ] = f2(); + auto& [ xr2, yr2 ] = f2(); + const auto [ x3, y3 ] = f3(); + + } + + namespace test_exception_spec_type_system + { + + struct Good {}; + struct Bad {}; + + void g1() noexcept; + void g2(); + + template<typename T> + Bad + f(T*, T*); + + template<typename T1, typename T2> + Good + f(T1*, T2*); + + static_assert (std::is_same_v<Good, decltype(f(g1, g2))>); + + } + + namespace test_inline_variables + { + + template<class T> void f(T) + {} + + template<class T> inline T g(T) + { + return T{}; + } + + template<> inline void f<>(int) + {} + + template<> int g<>(int) + { + return 5; + } + + } + +} // namespace cxx17 + +#endif // __cplusplus < 201703L + +]]) diff --git a/src/keys/treekeyidx.cpp b/src/keys/treekeyidx.cpp index c4716868..22a7e4c1 100644 --- a/src/keys/treekeyidx.cpp +++ b/src/keys/treekeyidx.cpp @@ -22,6 +22,7 @@ #include <treekeyidx.h> +#include <cstdint> #include <fcntl.h> #include <stdio.h> #include <errno.h> @@ -177,7 +178,7 @@ bool TreeKeyIdx::nextSibling() { bool TreeKeyIdx::previousSibling() { TreeNode iterator; - __s32 target = currentNode.offset; + int32_t target = currentNode.offset; if (currentNode.parent > -1) { getTreeNodeFromIdxOffset(currentNode.parent, &iterator); getTreeNodeFromIdxOffset(iterator.firstChild, &iterator); @@ -207,10 +208,10 @@ void TreeKeyIdx::append() { while (lastSib.next > -1) { getTreeNodeFromIdxOffset(lastSib.next, &lastSib); } - __u32 idxOffset = (__u32)idxfd->seek(0, SEEK_END); + uint32_t idxOffset = (uint32_t)idxfd->seek(0, SEEK_END); lastSib.next = idxOffset; saveTreeNodeOffsets(&lastSib); - __u32 parent = currentNode.parent; + uint32_t parent = currentNode.parent; currentNode.clear(); currentNode.offset = idxOffset; currentNode.parent = parent; @@ -224,10 +225,10 @@ void TreeKeyIdx::appendChild() { append(); } else { - __u32 idxOffset = (__u32)idxfd->seek(0, SEEK_END); + uint32_t idxOffset = (uint32_t)idxfd->seek(0, SEEK_END); currentNode.firstChild = idxOffset; saveTreeNodeOffsets(¤tNode); - __u32 parent = currentNode.offset; + uint32_t parent = currentNode.offset; currentNode.clear(); currentNode.offset = idxOffset; currentNode.parent = parent; @@ -257,7 +258,7 @@ void TreeKeyIdx::remove() { } if (!done) { TreeNode iterator; - __s32 target = currentNode.offset; + int32_t target = currentNode.offset; if (currentNode.parent > -1) { getTreeNodeFromIdxOffset(currentNode.parent, &iterator); getTreeNodeFromIdxOffset(iterator.firstChild, &iterator); @@ -331,8 +332,8 @@ signed char TreeKeyIdx::create(const char *ipath) { void TreeKeyIdx::getTreeNodeFromDatOffset(long ioffset, TreeNode *node) const { unsnappedKeyText = ""; char ch; - __s32 tmp; - __u16 tmp2; + int32_t tmp; + uint16_t tmp2; if (datfd && datfd->getFd() >= 0) { @@ -379,7 +380,7 @@ void TreeKeyIdx::getTreeNodeFromDatOffset(long ioffset, TreeNode *node) const { char TreeKeyIdx::getTreeNodeFromIdxOffset(long ioffset, TreeNode *node) const { unsnappedKeyText = ""; - __u32 offset; + uint32_t offset; char error = KEYERR_OUTOFBOUNDS; if (ioffset < 0) { @@ -387,7 +388,7 @@ char TreeKeyIdx::getTreeNodeFromIdxOffset(long ioffset, TreeNode *node) const { error = 77; // out of bounds but still position to 0; } - node->offset = (__s32)ioffset; + node->offset = (int32_t)ioffset; if (idxfd && idxfd->getFd() >= 0) { idxfd->seek(ioffset, SEEK_SET); if (idxfd->read(&offset, 4) == 4) { @@ -421,13 +422,13 @@ void TreeKeyIdx::setOffset(unsigned long offset) { void TreeKeyIdx::saveTreeNodeOffsets(TreeNode *node) { unsnappedKeyText = ""; long datOffset = 0; - __s32 tmp; + int32_t tmp; if (idxfd && idxfd->getFd() >= 0) { idxfd->seek(node->offset, SEEK_SET); if (idxfd->read(&tmp, 4) != 4) { datOffset = datfd->seek(0, SEEK_END); - tmp = (__s32)archtosword32(datOffset); + tmp = (int32_t)archtosword32(datOffset); idxfd->write(&tmp, 4); } else { @@ -435,13 +436,13 @@ void TreeKeyIdx::saveTreeNodeOffsets(TreeNode *node) { datfd->seek(datOffset, SEEK_SET); } - tmp = (__s32)archtosword32(node->parent); + tmp = (int32_t)archtosword32(node->parent); datfd->write(&tmp, 4); - tmp = (__s32)archtosword32(node->next); + tmp = (int32_t)archtosword32(node->next); datfd->write(&tmp, 4); - tmp = (__s32)archtosword32(node->firstChild); + tmp = (int32_t)archtosword32(node->firstChild); datfd->write(&tmp, 4); } } @@ -488,12 +489,12 @@ void TreeKeyIdx::copyFrom(const TreeKeyIdx &ikey) { void TreeKeyIdx::saveTreeNode(TreeNode *node) { long datOffset = 0; - __s32 tmp; + int32_t tmp; if (idxfd && idxfd->getFd() >= 0) { idxfd->seek(node->offset, SEEK_SET); datOffset = datfd->seek(0, SEEK_END); - tmp = (__s32)archtosword32(datOffset); + tmp = (int32_t)archtosword32(datOffset); idxfd->write(&tmp, 4); saveTreeNodeOffsets(node); @@ -502,7 +503,7 @@ void TreeKeyIdx::saveTreeNode(TreeNode *node) { char null = 0; datfd->write(&null, 1); - __u16 tmp2 = archtosword16(node->dsize); + uint16_t tmp2 = archtosword16(node->dsize); datfd->write(&tmp2, 2); if (node->dsize) { diff --git a/src/keys/versekey.cpp b/src/keys/versekey.cpp index 8d9612d7..f8239abd 100644 --- a/src/keys/versekey.cpp +++ b/src/keys/versekey.cpp @@ -28,6 +28,7 @@ #include <stdlib.h> #include <ctype.h> +#include <cstdint> #include <utilstr.h> #include <stringmgr.h> #include <swkey.h> @@ -776,7 +777,7 @@ terminate_range: lastKey->setPosition(TOP); tmpListKey << *lastKey; ((VerseKey *)tmpListKey.getElement())->setAutoNormalize(isAutoNormalize()); - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } else { if (!dash) { // if last separator was not a dash just add @@ -790,7 +791,7 @@ terminate_range: *lastKey = TOP; tmpListKey << *lastKey; ((VerseKey *)tmpListKey.getElement())->setAutoNormalize(isAutoNormalize()); - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } else { bool f = false; @@ -805,7 +806,7 @@ terminate_range: *lastKey = TOP; tmpListKey << *lastKey; ((VerseKey *)tmpListKey.getElement())->setAutoNormalize(isAutoNormalize()); - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } } else if (expandRange) { @@ -818,7 +819,7 @@ terminate_range: newElement->setUpperBound(*curKey); *lastKey = *curKey; *newElement = TOP; - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } } } @@ -1049,7 +1050,7 @@ terminate_range: lastKey->setLowerBound(*curKey); *lastKey = TOP; tmpListKey << *lastKey; - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } else { if (!dash) { // if last separator was not a dash just add @@ -1062,7 +1063,7 @@ terminate_range: lastKey->setUpperBound(*curKey); *lastKey = TOP; tmpListKey << *lastKey; - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } else { bool f = false; @@ -1076,7 +1077,7 @@ terminate_range: lastKey->setUpperBound(*curKey); *lastKey = TOP; tmpListKey << *lastKey; - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } } else if (expandRange) { @@ -1088,7 +1089,7 @@ terminate_range: *curKey = MAXVERSE; newElement->setUpperBound(*curKey); *newElement = TOP; - tmpListKey.getElement()->userData = (__u64)(bufStart+(buf-iBuf.c_str())); + tmpListKey.getElement()->userData = (uint64_t)(bufStart+(buf-iBuf.c_str())); } } } diff --git a/src/mgr/stringmgr.cpp b/src/mgr/stringmgr.cpp index a88fa439..c371e127 100644 --- a/src/mgr/stringmgr.cpp +++ b/src/mgr/stringmgr.cpp @@ -20,6 +20,7 @@ * */ +#include <cstdint> #include <ctype.h> #include <stringmgr.h> #include <swlog.h> @@ -145,10 +146,10 @@ class ICUStringMgr : public StringMgr { public: virtual char *upperUTF8(char *, unsigned int maxlen = 0) const; virtual char *lowerUTF8(char *, unsigned int maxlen = 0) const; - virtual bool isUpper(__u32 character) const; - virtual bool isLower(__u32 character) const; - virtual bool isDigit(__u32 character) const; - virtual bool isAlpha(__u32 character) const; + virtual bool isUpper(uint32_t character) const; + virtual bool isLower(uint32_t character) const; + virtual bool isDigit(uint32_t character) const; + virtual bool isAlpha(uint32_t character) const; protected: virtual bool supportsUnicode() const { return true; }; @@ -276,16 +277,16 @@ char *StringMgr::lowerUTF8(char *t, unsigned int maxlen) const { return t; } -bool StringMgr::isUpper(__u32 character) const { +bool StringMgr::isUpper(uint32_t character) const { return isupper(character); } -bool StringMgr::isLower(__u32 character) const { +bool StringMgr::isLower(uint32_t character) const { return islower(character); } -bool StringMgr::isDigit(__u32 character) const { +bool StringMgr::isDigit(uint32_t character) const { return isdigit(character); } -bool StringMgr::isAlpha(__u32 character) const { +bool StringMgr::isAlpha(uint32_t character) const { return isalpha(character); } @@ -389,16 +390,16 @@ char *ICUStringMgr::lowerUTF8(char *buf, unsigned int maxlen) const { return ret; } -bool ICUStringMgr::isUpper(__u32 character) const { +bool ICUStringMgr::isUpper(uint32_t character) const { return u_isupper(character); } -bool ICUStringMgr::isLower(__u32 character) const { +bool ICUStringMgr::isLower(uint32_t character) const { return u_islower(character); } -bool ICUStringMgr::isDigit(__u32 character) const { +bool ICUStringMgr::isDigit(uint32_t character) const { return u_isdigit(character); } -bool ICUStringMgr::isAlpha(__u32 character) const { +bool ICUStringMgr::isAlpha(uint32_t character) const { return u_isalpha(character); } diff --git a/src/modules/comments/rawfiles/rawfiles.cpp b/src/modules/comments/rawfiles/rawfiles.cpp index bfd3e1da..9ae60b25 100644 --- a/src/modules/comments/rawfiles/rawfiles.cpp +++ b/src/modules/comments/rawfiles/rawfiles.cpp @@ -22,6 +22,7 @@ * */ +#include <cstdint> #include <ctype.h> #include <stdio.h> #include <fcntl.h> @@ -187,7 +188,7 @@ void RawFiles::deleteEntry() { const char *RawFiles::getNextFilename() { static SWBuf incfile; - __u32 number = 0; + uint32_t number = 0; FileDesc *datafile; incfile.setFormatted("%s/incfile", path); @@ -213,7 +214,7 @@ const char *RawFiles::getNextFilename() { char RawFiles::createModule(const char *path) { char *incfile = new char [ strlen (path) + 16 ]; - __u32 zero = 0; + uint32_t zero = 0; zero = archtosword32(zero); FileDesc *datafile; diff --git a/src/modules/common/entriesblk.cpp b/src/modules/common/entriesblk.cpp index c2c02e41..e9aa3ee7 100644 --- a/src/modules/common/entriesblk.cpp +++ b/src/modules/common/entriesblk.cpp @@ -20,6 +20,7 @@ * */ +#include <cstdint> #include <entriesblk.h> #include <stdlib.h> #include <string.h> @@ -37,13 +38,13 @@ EntriesBlock::EntriesBlock(const char *iBlock, unsigned long size) { memcpy(block, iBlock, size); } else { - block = (char *)calloc(1, sizeof(__u32)); + block = (char *)calloc(1, sizeof(uint32_t)); } } EntriesBlock::EntriesBlock() { - block = (char *)calloc(1, sizeof(__u32)); + block = (char *)calloc(1, sizeof(uint32_t)); } @@ -53,22 +54,22 @@ EntriesBlock::~EntriesBlock() { void EntriesBlock::setCount(int count) { - __u32 rawCount = archtosword32(count); - memcpy(block, &rawCount, sizeof(__u32)); + uint32_t rawCount = archtosword32(count); + memcpy(block, &rawCount, sizeof(uint32_t)); } int EntriesBlock::getCount() { - __u32 count = 0; - memcpy(&count, block, sizeof(__u32)); + uint32_t count = 0; + memcpy(&count, block, sizeof(uint32_t)); count = swordtoarch32(count); return count; } void EntriesBlock::getMetaEntry(int index, unsigned long *offset, unsigned long *size) { - __u32 rawOffset = 0; - __u32 rawSize = 0; + uint32_t rawOffset = 0; + uint32_t rawSize = 0; *offset = 0; *size = 0; if (index >= getCount()) // assert index < count @@ -84,8 +85,8 @@ void EntriesBlock::getMetaEntry(int index, unsigned long *offset, unsigned long void EntriesBlock::setMetaEntry(int index, unsigned long offset, unsigned long size) { - __u32 rawOffset = (__u32)archtosword32(offset); - __u32 rawSize = (__u32)archtosword32(size); + uint32_t rawOffset = (uint32_t)archtosword32(offset); + uint32_t rawSize = (uint32_t)archtosword32(size); if (index >= getCount()) // assert index < count return; diff --git a/src/modules/common/rawstr.cpp b/src/modules/common/rawstr.cpp index 0541b5c3..7bd2d8c7 100644 --- a/src/modules/common/rawstr.cpp +++ b/src/modules/common/rawstr.cpp @@ -23,6 +23,7 @@ * */ +#include <cstdint> #include <stdio.h> #include <fcntl.h> #include <errno.h> @@ -145,7 +146,7 @@ void RawStr::getIDXBufDat(long ioffset, char **buf) const void RawStr::getIDXBuf(long ioffset, char **buf) const { - __u32 offset; + uint32_t offset; if (idxfd && idxfd->getFd() >= 0) { idxfd->seek(ioffset, SEEK_SET); @@ -170,7 +171,7 @@ void RawStr::getIDXBuf(long ioffset, char **buf) const * RET: error status -1 general error; -2 new file */ -signed char RawStr::findOffset(const char *ikey, __u32 *start, __u16 *size, long away, __u32 *idxoff) const +signed char RawStr::findOffset(const char *ikey, uint32_t *start, uint16_t *size, long away, uint32_t *idxoff) const { char *trybuf, *maxbuf, *key = 0, quitflag = 0; signed char retval = -1; @@ -239,13 +240,13 @@ signed char RawStr::findOffset(const char *ikey, __u32 *start, __u16 *size, long idxfd->seek(tryoff, SEEK_SET); - __u32 tmpStart; - __u16 tmpSize; + uint32_t tmpStart; + uint16_t tmpSize; *start = *size = tmpStart = tmpSize = 0; idxfd->read(&tmpStart, 4); idxfd->read(&tmpSize, 2); if (idxoff) - *idxoff = (__u32)tryoff; + *idxoff = (uint32_t)tryoff; *start = swordtoarch32(tmpStart); *size = swordtoarch16(tmpSize); @@ -264,17 +265,17 @@ signed char RawStr::findOffset(const char *ikey, __u32 *start, __u16 *size, long if (bad) { if(!awayFromSubstrCheck) retval = -1; - *start = (__u32)laststart; + *start = (uint32_t)laststart; *size = lastsize; tryoff = lasttry; if (idxoff) - *idxoff = (__u32)tryoff; + *idxoff = (uint32_t)tryoff; break; } idxfd->read(&tmpStart, 4); idxfd->read(&tmpSize, 2); if (idxoff) - *idxoff = (__u32)tryoff; + *idxoff = (uint32_t)tryoff; *start = swordtoarch32(tmpStart); *size = swordtoarch16(tmpSize); @@ -306,12 +307,12 @@ signed char RawStr::findOffset(const char *ikey, __u32 *start, __u16 *size, long * */ -void RawStr::readText(__u32 istart, __u16 *isize, char **idxbuf, SWBuf &buf) const +void RawStr::readText(uint32_t istart, uint16_t *isize, char **idxbuf, SWBuf &buf) const { unsigned int ch; char *idxbuflocal = 0; getIDXBufDat(istart, &idxbuflocal); - __u32 start = istart; + uint32_t start = istart; do { if (*idxbuf) @@ -368,12 +369,12 @@ void RawStr::readText(__u32 istart, __u16 *isize, char **idxbuf, SWBuf &buf) con void RawStr::doSetText(const char *ikey, const char *buf, long len) { - __u32 start, outstart; - __u32 idxoff; - __u32 endoff; - __s32 shiftSize; - __u16 size; - __u16 outsize; + uint32_t start, outstart; + uint32_t idxoff; + uint32_t endoff; + int32_t shiftSize; + uint16_t size; + uint16_t outsize; char *tmpbuf = 0; char *key = 0; char *dbKey = 0; @@ -426,7 +427,7 @@ void RawStr::doSetText(const char *ikey, const char *buf, long len) while (true); // while we're resolving links } - endoff = (__u32)idxfd->seek(0, SEEK_END); + endoff = (uint32_t)idxfd->seek(0, SEEK_END); shiftSize = endoff - idxoff; @@ -442,7 +443,7 @@ void RawStr::doSetText(const char *ikey, const char *buf, long len) memcpy(outbuf + size, buf, len); size = outsize = size + (len); - start = outstart = (__u32)datfd->seek(0, SEEK_END); + start = outstart = (uint32_t)datfd->seek(0, SEEK_END); outstart = archtosword32(start); outsize = archtosword16(size); diff --git a/src/modules/common/rawstr4.cpp b/src/modules/common/rawstr4.cpp index 2d49b3d7..675d00e9 100644 --- a/src/modules/common/rawstr4.cpp +++ b/src/modules/common/rawstr4.cpp @@ -23,6 +23,7 @@ * */ +#include <cstdint> #include <stdio.h> #include <fcntl.h> #include <errno.h> @@ -145,7 +146,7 @@ void RawStr4::getIDXBufDat(long ioffset, char **buf) const void RawStr4::getIDXBuf(long ioffset, char **buf) const { - __u32 offset; + uint32_t offset; if ((unsigned long)idxfd > 0) { idxfd->seek(ioffset, SEEK_SET); @@ -179,7 +180,7 @@ void RawStr4::getIDXBuf(long ioffset, char **buf) const * RET: error status -1 general error; -2 new file */ -signed char RawStr4::findOffset(const char *ikey, __u32 *start, __u32 *size, long away, __u32 *idxoff) const +signed char RawStr4::findOffset(const char *ikey, uint32_t *start, uint32_t *size, long away, uint32_t *idxoff) const { char *trybuf, *maxbuf, *key = 0, quitflag = 0; signed char retval = -1; @@ -249,12 +250,12 @@ signed char RawStr4::findOffset(const char *ikey, __u32 *start, __u32 *size, lon idxfd->seek(tryoff, SEEK_SET); - __u32 tmpStart, tmpSize; + uint32_t tmpStart, tmpSize; *start = *size = tmpStart = tmpSize = 0; idxfd->read(&tmpStart, 4); idxfd->read(&tmpSize, 4); if (idxoff) - *idxoff = (__u32)tryoff; + *idxoff = (uint32_t)tryoff; *start = swordtoarch32(tmpStart); *size = swordtoarch32(tmpSize); @@ -273,17 +274,17 @@ signed char RawStr4::findOffset(const char *ikey, __u32 *start, __u32 *size, lon if (bad) { if(!awayFromSubstrCheck) retval = -1; - *start = (__u32)laststart; - *size = (__u32)lastsize; + *start = (uint32_t)laststart; + *size = (uint32_t)lastsize; tryoff = lasttry; if (idxoff) - *idxoff = (__u32)tryoff; + *idxoff = (uint32_t)tryoff; break; } idxfd->read(&tmpStart, 4); idxfd->read(&tmpSize, 4); if (idxoff) - *idxoff = (__u32)tryoff; + *idxoff = (uint32_t)tryoff; *start = swordtoarch32(tmpStart); *size = swordtoarch32(tmpSize); @@ -315,12 +316,12 @@ signed char RawStr4::findOffset(const char *ikey, __u32 *start, __u32 *size, lon * */ -void RawStr4::readText(__u32 istart, __u32 *isize, char **idxbuf, SWBuf &buf) const +void RawStr4::readText(uint32_t istart, uint32_t *isize, char **idxbuf, SWBuf &buf) const { unsigned int ch; char *idxbuflocal = 0; getIDXBufDat(istart, &idxbuflocal); - __u32 start = istart; + uint32_t start = istart; do { if (*idxbuf) @@ -376,12 +377,12 @@ void RawStr4::readText(__u32 istart, __u32 *isize, char **idxbuf, SWBuf &buf) co void RawStr4::doSetText(const char *ikey, const char *buf, long len) { - __u32 start, outstart; - __u32 idxoff; - __u32 endoff; - __s32 shiftSize; - __u32 size; - __u32 outsize; + uint32_t start, outstart; + uint32_t idxoff; + uint32_t endoff; + int32_t shiftSize; + uint32_t size; + uint32_t outsize; char *tmpbuf = 0; char *key = 0; char *dbKey = 0; @@ -434,7 +435,7 @@ void RawStr4::doSetText(const char *ikey, const char *buf, long len) { while (true); // while we're resolving links } - endoff = (__u32)idxfd->seek(0, SEEK_END); + endoff = (uint32_t)idxfd->seek(0, SEEK_END); shiftSize = endoff - idxoff; @@ -448,9 +449,9 @@ void RawStr4::doSetText(const char *ikey, const char *buf, long len) { sprintf(outbuf, "%s%c%c", key, 13, 10); size = strlen(outbuf); memcpy(outbuf + size, buf, len); - size = outsize = size + (__u32)len; + size = outsize = size + (uint32_t)len; - start = outstart = (__u32)datfd->seek(0, SEEK_END); + start = outstart = (uint32_t)datfd->seek(0, SEEK_END); outstart = archtosword32(start); outsize = archtosword32(size); diff --git a/src/modules/common/rawverse.cpp b/src/modules/common/rawverse.cpp index 3e79b88d..04b52404 100644 --- a/src/modules/common/rawverse.cpp +++ b/src/modules/common/rawverse.cpp @@ -25,6 +25,7 @@ +#include <cstdint> #include <ctype.h> #include <stdio.h> #include <fcntl.h> @@ -122,8 +123,8 @@ void RawVerse::findOffset(char testmt, long idxoff, long *start, unsigned short if (idxfp[testmt-1]->getFd() >= 0) { idxfp[testmt-1]->seek(idxoff, SEEK_SET); - __s32 tmpStart; - __u16 tmpSize; + int32_t tmpStart; + uint16_t tmpSize; idxfp[testmt-1]->read(&tmpStart, 4); long len = idxfp[testmt-1]->read(&tmpSize, 2); // read size @@ -177,8 +178,8 @@ void RawVerse::readText(char testmt, long start, unsigned short size, SWBuf &buf void RawVerse::doSetText(char testmt, long idxoff, const char *buf, long len) { - __s32 start; - __u16 size; + int32_t start; + uint16_t size; idxoff *= 6; if (!testmt) @@ -186,7 +187,7 @@ void RawVerse::doSetText(char testmt, long idxoff, const char *buf, long len) size = (len < 0) ? strlen(buf) : len; - start = (__s32)textfp[testmt-1]->seek(0, SEEK_END); + start = (int32_t)textfp[testmt-1]->seek(0, SEEK_END); idxfp[testmt-1]->seek(idxoff, SEEK_SET); if (size) { @@ -217,8 +218,8 @@ void RawVerse::doSetText(char testmt, long idxoff, const char *buf, long len) */ void RawVerse::doLinkEntry(char testmt, long destidxoff, long srcidxoff) { - __s32 start; - __u16 size; + int32_t start; + uint16_t size; destidxoff *= 6; srcidxoff *= 6; @@ -282,8 +283,8 @@ char RawVerse::createModule(const char *ipath, const char *v11n) vk.setVersificationSystem(v11n); vk.setIntros(1); - __s32 offset = 0; - __u16 size = 0; + int32_t offset = 0; + uint16_t size = 0; offset = archtosword32(offset); size = archtosword16(size); diff --git a/src/modules/common/rawverse4.cpp b/src/modules/common/rawverse4.cpp index 67a43d8f..b4dc1651 100644 --- a/src/modules/common/rawverse4.cpp +++ b/src/modules/common/rawverse4.cpp @@ -26,6 +26,7 @@ +#include <cstdint> #include <ctype.h> #include <stdio.h> #include <fcntl.h> @@ -123,8 +124,8 @@ void RawVerse4::findOffset(char testmt, long idxoff, long *start, unsigned long if (idxfp[testmt-1]->getFd() >= 0) { idxfp[testmt-1]->seek(idxoff, SEEK_SET); - __u32 tmpStart; - __u32 tmpSize; + uint32_t tmpStart; + uint32_t tmpSize; idxfp[testmt-1]->read(&tmpStart, 4); long len = idxfp[testmt-1]->read(&tmpSize, 4); // read size @@ -178,16 +179,16 @@ void RawVerse4::readText(char testmt, long start, unsigned long size, SWBuf &buf void RawVerse4::doSetText(char testmt, long idxoff, const char *buf, long len) { - __u32 start; - __u32 size; + uint32_t start; + uint32_t size; idxoff *= 8; if (!testmt) testmt = ((idxfp[1]) ? 1:2); - size = (__u32)((len < 0) ? strlen(buf) : len); + size = (uint32_t)((len < 0) ? strlen(buf) : len); - start = (__u32)textfp[testmt-1]->seek(0, SEEK_END); + start = (uint32_t)textfp[testmt-1]->seek(0, SEEK_END); idxfp[testmt-1]->seek(idxoff, SEEK_SET); if (size) { @@ -218,8 +219,8 @@ void RawVerse4::doSetText(char testmt, long idxoff, const char *buf, long len) */ void RawVerse4::doLinkEntry(char testmt, long destidxoff, long srcidxoff) { - __u32 start; - __u32 size; + uint32_t start; + uint32_t size; destidxoff *= 8; srcidxoff *= 8; @@ -282,8 +283,8 @@ char RawVerse4::createModule(const char *ipath, const char *v11n) VerseKey vk; vk.setVersificationSystem(v11n); vk.setIntros(1); - __u32 offset = 0; - __u32 size = 0; + uint32_t offset = 0; + uint32_t size = 0; offset = archtosword32(offset); size = archtosword32(size); diff --git a/src/modules/common/zstr.cpp b/src/modules/common/zstr.cpp index 324372da..55b3f6f3 100644 --- a/src/modules/common/zstr.cpp +++ b/src/modules/common/zstr.cpp @@ -23,6 +23,7 @@ */ +#include <cstdint> #include <stdio.h> #include <fcntl.h> #include <errno.h> @@ -167,7 +168,7 @@ void zStr::getKeyFromDatOffset(long ioffset, char **buf) const void zStr::getKeyFromIdxOffset(long ioffset, char **buf) const { - __u32 offset; + uint32_t offset; if (idxfd && idxfd->getFd() >= 0) { idxfd->seek(ioffset, SEEK_SET); @@ -194,13 +195,13 @@ signed char zStr::findKeyIndex(const char *ikey, long *idxoff, long away) const { char *maxbuf = 0, *trybuf = 0, *key = 0, quitflag = 0; signed char retval = 0; - __s32 headoff, tailoff, tryoff = 0, maxoff = 0; - __u32 start, size; + int32_t headoff, tailoff, tryoff = 0, maxoff = 0; + uint32_t start, size; int diff = 0; bool awayFromSubstrCheck = false; if (idxfd->getFd() >= 0) { - tailoff = maxoff = (__s32)idxfd->seek(0, SEEK_END) - IDXENTRYSIZE; + tailoff = maxoff = (int32_t)idxfd->seek(0, SEEK_END) - IDXENTRYSIZE; if (*ikey) { headoff = 0; stdstr(&key, ikey, 3); @@ -212,7 +213,7 @@ signed char zStr::findKeyIndex(const char *ikey, long *idxoff, long away) const getKeyFromIdxOffset(maxoff, &maxbuf); while (headoff < tailoff) { - tryoff = ((__s32)lastoff == -1) ? headoff + (((((tailoff / IDXENTRYSIZE) - (headoff / IDXENTRYSIZE))) / 2) * IDXENTRYSIZE) : (__s32)lastoff; + tryoff = ((int32_t)lastoff == -1) ? headoff + (((((tailoff / IDXENTRYSIZE) - (headoff / IDXENTRYSIZE))) / 2) * IDXENTRYSIZE) : (int32_t)lastoff; lastoff = -1; getKeyFromIdxOffset(tryoff, &trybuf); @@ -268,9 +269,9 @@ signed char zStr::findKeyIndex(const char *ikey, long *idxoff, long away) const *idxoff = tryoff; while (away) { - __u32 laststart = start; - __u32 lastsize = size; - __s32 lasttry = tryoff; + uint32_t laststart = start; + uint32_t lastsize = size; + int32_t lasttry = tryoff; tryoff += (away > 0) ? IDXENTRYSIZE : -IDXENTRYSIZE; bool bad = false; @@ -328,8 +329,8 @@ void zStr::getText(long offset, char **idxbuf, char **buf) const { char *ch; char *idxbuflocal = 0; getKeyFromIdxOffset(offset, &idxbuflocal); - __u32 start; - __u32 size; + uint32_t start; + uint32_t size; do { idxfd->seek(offset, SEEK_SET); @@ -368,16 +369,16 @@ void zStr::getText(long offset, char **idxbuf, char **buf) const { while (true); // while we're resolving links if (idxbuflocal) { - __u32 localsize = (__u32)strlen(idxbuflocal); + uint32_t localsize = (uint32_t)strlen(idxbuflocal); localsize = (localsize < (size - 1)) ? localsize : (size - 1); strncpy(*idxbuf, idxbuflocal, localsize); (*idxbuf)[localsize] = 0; free(idxbuflocal); } - __u32 block = 0; - __u32 entry = 0; - memmove(&block, *buf, sizeof(__u32)); - memmove(&entry, *buf + sizeof(__u32), sizeof(__u32)); + uint32_t block = 0; + uint32_t entry = 0; + memmove(&block, *buf, sizeof(uint32_t)); + memmove(&entry, *buf + sizeof(uint32_t), sizeof(uint32_t)); block = swordtoarch32(block); entry = swordtoarch32(entry); getCompressedText(block, entry, buf); @@ -391,10 +392,10 @@ void zStr::getText(long offset, char **idxbuf, char **buf) const { void zStr::getCompressedText(long block, long entry, char **buf) const { - __u32 size = 0; + uint32_t size = 0; if (cacheBlockIndex != block) { - __u32 start = 0; + uint32_t start = 0; zdxfd->seek(block * ZDXENTRYSIZE, SEEK_SET); zdxfd->read(&start, 4); @@ -418,7 +419,7 @@ void zStr::getCompressedText(long block, long entry, char **buf) const { cacheBlock = new EntriesBlock(rawBuf, len); cacheBlockIndex = block; } - size = (__u32)cacheBlock->getEntrySize(entry); + size = (uint32_t)cacheBlock->getEntrySize(entry); *buf = (*buf) ? (char *)realloc(*buf, size*2 + 1) : (char *)malloc(size*2 + 1); strcpy(*buf, cacheBlock->getEntry(entry)); } @@ -436,11 +437,11 @@ void zStr::setText(const char *ikey, const char *buf, long len) { static const char nl[] = {13, 10}; - __u32 start, outstart; - __u32 size, outsize; - __s32 endoff; + uint32_t start, outstart; + uint32_t size, outsize; + int32_t endoff; long idxoff = 0; - __s32 shiftSize; + int32_t shiftSize; char *tmpbuf = 0; char *key = 0; char *dbKey = 0; @@ -499,9 +500,9 @@ void zStr::setText(const char *ikey, const char *buf, long len) { } } - endoff = (__s32)idxfd->seek(0, SEEK_END); + endoff = (int32_t)idxfd->seek(0, SEEK_END); - shiftSize = endoff - (__s32)idxoff; + shiftSize = endoff - (int32_t)idxoff; if (shiftSize > 0) { idxBytes = new char [ shiftSize ]; @@ -511,7 +512,7 @@ void zStr::setText(const char *ikey, const char *buf, long len) { outbuf = new char [ len + strlen(key) + 5 ]; sprintf(outbuf, "%s%c%c", key, 13, 10); - size = (__u32)strlen(outbuf); + size = (uint32_t)strlen(outbuf); if (len > 0) { // NOT a link if (!cacheBlock) { flushCache(); @@ -523,20 +524,20 @@ void zStr::setText(const char *ikey, const char *buf, long len) { cacheBlock = new EntriesBlock(); cacheBlockIndex = (zdxfd->seek(0, SEEK_END) / ZDXENTRYSIZE); } - __u32 entry = cacheBlock->addEntry(buf); + uint32_t entry = cacheBlock->addEntry(buf); cacheDirty = true; - outstart = (__u32)archtosword32(cacheBlockIndex); + outstart = (uint32_t)archtosword32(cacheBlockIndex); outsize = archtosword32(entry); - memcpy (outbuf + size, &outstart, sizeof(__u32)); - memcpy (outbuf + size + sizeof(__u32), &outsize, sizeof(__u32)); - size += (sizeof(__u32) * 2); + memcpy (outbuf + size, &outstart, sizeof(uint32_t)); + memcpy (outbuf + size + sizeof(uint32_t), &outsize, sizeof(uint32_t)); + size += (sizeof(uint32_t) * 2); } else { // link memcpy(outbuf + size, buf, len); size += len; } - start = (__u32)datfd->seek(0, SEEK_END); + start = (uint32_t)datfd->seek(0, SEEK_END); outstart = archtosword32(start); outsize = archtosword32(size); @@ -593,9 +594,9 @@ void zStr::flushCache() const { if (cacheBlock) { if (cacheDirty) { - __u32 start = 0; + uint32_t start = 0; unsigned long size = 0; - __u32 outstart = 0, outsize = 0; + uint32_t outstart = 0, outsize = 0; const char *rawBuf = cacheBlock->getRawData(&size); compressor->Buf(rawBuf, &size); @@ -611,7 +612,7 @@ void zStr::flushCache() const { unsigned long zdtSize = zdtfd->seek(0, SEEK_END); if ((cacheBlockIndex * ZDXENTRYSIZE) > (zdxSize - ZDXENTRYSIZE)) { // New Block - start = (__u32)zdtSize; + start = (uint32_t)zdtSize; } else { zdxfd->seek(cacheBlockIndex * ZDXENTRYSIZE, SEEK_SET); @@ -626,14 +627,14 @@ void zStr::flushCache() const { size = outsize; } else { // middle and bigger-- we have serious problems, for now let's put it at the end = lots of wasted space - start = (__u32)zdtSize; + start = (uint32_t)zdtSize; } } outstart = archtosword32(start); - outsize = archtosword32((__u32)size); + outsize = archtosword32((uint32_t)size); zdxfd->seek(cacheBlockIndex * ZDXENTRYSIZE, SEEK_SET); zdtfd->seek(start, SEEK_SET); diff --git a/src/modules/common/zverse.cpp b/src/modules/common/zverse.cpp index d54c67d9..1a0a7c9d 100644 --- a/src/modules/common/zverse.cpp +++ b/src/modules/common/zverse.cpp @@ -25,6 +25,7 @@ +#include <cstdint> #include <ctype.h> #include <stdio.h> #include <fcntl.h> @@ -149,9 +150,9 @@ zVerse::~zVerse() void zVerse::findOffset(char testmt, long idxoff, long *start, unsigned short *size, unsigned long *buffnum) const { - __u32 ulBuffNum = 0; // buffer number - __u32 ulVerseStart = 0; // verse offset within buffer - __u16 usVerseSize = 0; // verse size + uint32_t ulBuffNum = 0; // buffer number + uint32_t ulVerseStart = 0; // verse offset within buffer + uint16_t usVerseSize = 0; // verse size // set start to offset in // set size to // set @@ -204,9 +205,9 @@ void zVerse::findOffset(char testmt, long idxoff, long *start, unsigned short *s */ void zVerse::zReadText(char testmt, long start, unsigned short size, unsigned long ulBuffNum, SWBuf &inBuf) const { - __u32 ulCompOffset = 0; // compressed buffer start - __u32 ulCompSize = 0; // buffer size compressed - __u32 ulUnCompSize = 0; // buffer size uncompressed + uint32_t ulCompOffset = 0; // compressed buffer start + uint32_t ulCompSize = 0; // buffer size compressed + uint32_t ulUnCompSize = 0; // buffer size uncompressed if (!testmt) { testmt = ((idxfp[0]) ? 1:2); @@ -312,14 +313,14 @@ void zVerse::doSetText(char testmt, long idxoff, const char *buf, long len) { dirtyCache = true; - __u32 start; - __u16 size; - __u32 outBufIdx = (__u32)cacheBufIdx; + uint32_t start; + uint16_t size; + uint32_t outBufIdx = (uint32_t)cacheBufIdx; idxoff *= 10; size = len; - start = (__u32)strlen(cacheBuf); + start = (uint32_t)strlen(cacheBuf); if (!size) start = outBufIdx = 0; @@ -338,14 +339,14 @@ void zVerse::doSetText(char testmt, long idxoff, const char *buf, long len) { void zVerse::flushCache() const { if (dirtyCache) { - __u32 idxoff; - __u32 start, outstart; - __u32 size, outsize; - __u32 zsize, outzsize; + uint32_t idxoff; + uint32_t start, outstart; + uint32_t size, outsize; + uint32_t zsize, outzsize; - idxoff = (__u32)cacheBufIdx * 12; + idxoff = (uint32_t)cacheBufIdx * 12; if (cacheBuf) { - size = outsize = zsize = outzsize = (__u32)strlen(cacheBuf); + size = outsize = zsize = outzsize = (uint32_t)strlen(cacheBuf); if (size) { // if (compressor) { // delete compressor; @@ -354,16 +355,16 @@ void zVerse::flushCache() const { compressor->Buf(cacheBuf); unsigned long tmpSize; compressor->zBuf(&tmpSize); - outzsize = zsize = (__u32)tmpSize; + outzsize = zsize = (uint32_t)tmpSize; SWBuf buf; buf.setSize(zsize + 5); memcpy(buf.getRawData(), compressor->zBuf(&tmpSize), tmpSize); - outzsize = zsize = (__u32)tmpSize; + outzsize = zsize = (uint32_t)tmpSize; buf.setSize(zsize); rawZFilter(buf, 1); // 1 = encipher - start = outstart = (__u32)textfp[cacheTestament-1]->seek(0, SEEK_END); + start = outstart = (uint32_t)textfp[cacheTestament-1]->seek(0, SEEK_END); outstart = archtosword32(start); outsize = archtosword32(size); @@ -392,9 +393,9 @@ void zVerse::flushCache() const { */ void zVerse::doLinkEntry(char testmt, long destidxoff, long srcidxoff) { - __s32 bufidx; - __s32 start; - __u16 size; + int32_t bufidx; + int32_t start; + uint16_t size; destidxoff *= 10; srcidxoff *= 10; @@ -429,8 +430,8 @@ char zVerse::createModule(const char *ipath, int blockBound, const char *v11n) char *buf = new char [ strlen (ipath) + 20 ]; char retVal = 0; FileDesc *fd, *fd2; - __s32 offset = 0; - __s16 size = 0; + int32_t offset = 0; + int16_t size = 0; VerseKey vk; stdstr(&path, ipath); diff --git a/src/modules/common/zverse4.cpp b/src/modules/common/zverse4.cpp index c5f7d79b..2c842837 100644 --- a/src/modules/common/zverse4.cpp +++ b/src/modules/common/zverse4.cpp @@ -23,6 +23,7 @@ * */ +#include <cstdint> #include <ctype.h> #include <stdio.h> #include <fcntl.h> @@ -147,9 +148,9 @@ zVerse4::~zVerse4() void zVerse4::findOffset(char testmt, long idxoff, long *start, unsigned long *size, unsigned long *buffnum) const { - __u32 ulBuffNum = 0; // buffer number - __u32 ulVerseStart = 0; // verse offset within buffer - __u32 usVerseSize = 0; // verse size + uint32_t ulBuffNum = 0; // buffer number + uint32_t ulVerseStart = 0; // verse offset within buffer + uint32_t usVerseSize = 0; // verse size // set start to offset in // set size to // set @@ -202,9 +203,9 @@ void zVerse4::findOffset(char testmt, long idxoff, long *start, unsigned long *s */ void zVerse4::zReadText(char testmt, long start, unsigned long size, unsigned long ulBuffNum, SWBuf &inBuf) const { - __u32 ulCompOffset = 0; // compressed buffer start - __u32 ulCompSize = 0; // buffer size compressed - __u32 ulUnCompSize = 0; // buffer size uncompressed + uint32_t ulCompOffset = 0; // compressed buffer start + uint32_t ulCompSize = 0; // buffer size compressed + uint32_t ulUnCompSize = 0; // buffer size uncompressed if (!testmt) { testmt = ((idxfp[0]) ? 1:2); @@ -310,14 +311,14 @@ void zVerse4::doSetText(char testmt, long idxoff, const char *buf, long len) { dirtyCache = true; - __u32 start; - __u32 size; - __u32 outBufIdx = (__u32)cacheBufIdx; + uint32_t start; + uint32_t size; + uint32_t outBufIdx = (uint32_t)cacheBufIdx; idxoff *= 12; - size = (__u32)len; + size = (uint32_t)len; - start = (__u32)strlen(cacheBuf); + start = (uint32_t)strlen(cacheBuf); if (!size) start = outBufIdx = 0; @@ -336,28 +337,28 @@ void zVerse4::doSetText(char testmt, long idxoff, const char *buf, long len) { void zVerse4::flushCache() const { if (dirtyCache) { - __u32 idxoff; - __u32 start, outstart; - __u32 size, outsize; - __u32 zsize, outzsize; + uint32_t idxoff; + uint32_t start, outstart; + uint32_t size, outsize; + uint32_t zsize, outzsize; - idxoff = (__u32)cacheBufIdx * 12; + idxoff = (uint32_t)cacheBufIdx * 12; if (cacheBuf) { - size = outsize = zsize = outzsize = (__u32)strlen(cacheBuf); + size = outsize = zsize = outzsize = (uint32_t)strlen(cacheBuf); if (size) { compressor->Buf(cacheBuf); unsigned long tmpSize; compressor->zBuf(&tmpSize); - outzsize = zsize = (__u32)tmpSize; + outzsize = zsize = (uint32_t)tmpSize; SWBuf buf; buf.setSize(zsize + 5); memcpy(buf.getRawData(), compressor->zBuf(&tmpSize), tmpSize); - outzsize = zsize = (__u32)tmpSize; + outzsize = zsize = (uint32_t)tmpSize; buf.setSize(zsize); rawZFilter(buf, 1); // 1 = encipher - start = outstart = (__u32)textfp[cacheTestament-1]->seek(0, SEEK_END); + start = outstart = (uint32_t)textfp[cacheTestament-1]->seek(0, SEEK_END); outstart = archtosword32(start); outsize = archtosword32(size); @@ -386,9 +387,9 @@ void zVerse4::flushCache() const { */ void zVerse4::doLinkEntry(char testmt, long destidxoff, long srcidxoff) { - __s32 bufidx; - __s32 start; - __u32 size; + int32_t bufidx; + int32_t start; + uint32_t size; destidxoff *= 12; srcidxoff *= 12; @@ -423,8 +424,8 @@ char zVerse4::createModule(const char *ipath, int blockBound, const char *v11n) char *buf = new char [ strlen (ipath) + 20 ]; char retVal = 0; FileDesc *fd, *fd2; - __s32 offset = 0; - __s32 size = 0; + int32_t offset = 0; + int32_t size = 0; VerseKey vk; stdstr(&path, ipath); diff --git a/src/modules/filters/rtfhtml.cpp b/src/modules/filters/rtfhtml.cpp index c2cf73e0..39074393 100644 --- a/src/modules/filters/rtfhtml.cpp +++ b/src/modules/filters/rtfhtml.cpp @@ -21,6 +21,7 @@ * */ +#include <cstdint> #include <stdlib.h> #include <rtfhtml.h> #include <swbuf.h> @@ -53,8 +54,8 @@ char RTFHTML::processText(SWBuf &text, const SWKey *key, const SWModule *module) while (isdigit(*++end)); SWBuf num; num.append(from, end-from); - __s16 n = atoi(num.c_str()); - __u32 u = (__u16)n; + int16_t n = atoi(num.c_str()); + uint32_t u = (uint16_t)n; getUTF8FromUniChar(u, &text); from += (end-from); continue; diff --git a/src/modules/filters/utf8greekaccents.cpp b/src/modules/filters/utf8greekaccents.cpp index 9f235a7a..695aba1a 100644 --- a/src/modules/filters/utf8greekaccents.cpp +++ b/src/modules/filters/utf8greekaccents.cpp @@ -21,6 +21,7 @@ * */ +#include <cstdint> #include <stdlib.h> #include <map> #include <stdio.h> @@ -42,7 +43,7 @@ namespace { return &oVals; } - std::map<__u32, SWBuf> converters; + std::map<uint32_t, SWBuf> converters; class converters_init { public: converters_init() { @@ -350,9 +351,9 @@ char UTF8GreekAccents::processText(SWBuf &text, const SWKey *key, const SWModule SWBuf orig = text; const unsigned char* from = (unsigned char*)orig.c_str(); text = ""; - map<__u32, SWBuf>::const_iterator it = converters.end(); + map<uint32_t, SWBuf>::const_iterator it = converters.end(); while (*from) { - __u32 ch = getUniCharFromUTF8(&from, true); + uint32_t ch = getUniCharFromUTF8(&from, true); // if ch is bad, then convert to replacement char if (!ch) ch = 0xFFFD; diff --git a/src/modules/filters/utf8utf16.cpp b/src/modules/filters/utf8utf16.cpp index 7cbfe596..0a5ad2ab 100644 --- a/src/modules/filters/utf8utf16.cpp +++ b/src/modules/filters/utf8utf16.cpp @@ -21,6 +21,7 @@ */ +#include <cstdint> #include <utf8utf16.h> #include <utilstr.h> #include <swbuf.h> @@ -43,25 +44,25 @@ char UTF8UTF16::processText(SWBuf &text, const SWKey *key, const SWModule *modul text = ""; while (*from) { - __u32 ch = getUniCharFromUTF8(&from); + uint32_t ch = getUniCharFromUTF8(&from); if (!ch) continue; // invalid char if (ch < 0x10000) { text.setSize(text.size()+2); - *((__u16 *)(text.getRawData()+(text.size()-2))) = (__u16)ch; + *((uint16_t *)(text.getRawData()+(text.size()-2))) = (uint16_t)ch; } else { - __u16 utf16; - utf16 = (__s16)((ch - 0x10000) / 0x400 + 0xD800); + uint16_t utf16; + utf16 = (int16_t)((ch - 0x10000) / 0x400 + 0xD800); text.setSize(text.size()+4); - *((__u16 *)(text.getRawData()+(text.size()-4))) = utf16; - utf16 = (__s16)((ch - 0x10000) % 0x400 + 0xDC00); - *((__u16 *)(text.getRawData()+(text.size()-2))) = utf16; + *((uint16_t *)(text.getRawData()+(text.size()-4))) = utf16; + utf16 = (int16_t)((ch - 0x10000) % 0x400 + 0xDC00); + *((uint16_t *)(text.getRawData()+(text.size()-2))) = utf16; } } text.setSize(text.size()+2); - *((__u16 *)(text.getRawData()+(text.size()-2))) = (__u16)0; + *((uint16_t *)(text.getRawData()+(text.size()-2))) = (uint16_t)0; text.setSize(text.size()-2); return 0; diff --git a/src/modules/genbook/rawgenbook/rawgenbook.cpp b/src/modules/genbook/rawgenbook/rawgenbook.cpp index 4074cf9b..8df82e2e 100644 --- a/src/modules/genbook/rawgenbook/rawgenbook.cpp +++ b/src/modules/genbook/rawgenbook/rawgenbook.cpp @@ -23,6 +23,7 @@ +#include <cstdint> #include <stdio.h> #include <fcntl.h> @@ -98,8 +99,8 @@ bool RawGenBook::isWritable() const { SWBuf &RawGenBook::getRawEntryBuf() const { - __u32 offset = 0; - __u32 size = 0; + uint32_t offset = 0; + uint32_t size = 0; const TreeKey &key = getTreeKey(); @@ -133,8 +134,8 @@ SWBuf &RawGenBook::getRawEntryBuf() const { void RawGenBook::setEntry(const char *inbuf, long len) { - __u32 offset = (__u32)archtosword32(bdtfd->seek(0, SEEK_END)); - __u32 size = 0; + uint32_t offset = (uint32_t)archtosword32(bdtfd->seek(0, SEEK_END)); + uint32_t size = 0; TreeKeyIdx *key = ((TreeKeyIdx *)&(getTreeKey())); char userData[8]; @@ -144,7 +145,7 @@ void RawGenBook::setEntry(const char *inbuf, long len) { bdtfd->write(inbuf, len); - size = (__u32)archtosword32(len); + size = (uint32_t)archtosword32(len); memcpy(userData, &offset, 4); memcpy(userData+4, &size, 4); key->setUserData(userData, 8); diff --git a/src/modules/lexdict/rawld/rawld.cpp b/src/modules/lexdict/rawld/rawld.cpp index 2e758599..61579802 100644 --- a/src/modules/lexdict/rawld/rawld.cpp +++ b/src/modules/lexdict/rawld/rawld.cpp @@ -21,6 +21,8 @@ * */ +#include <cstdint> + #include <fcntl.h> #include <utilstr.h> @@ -73,8 +75,8 @@ bool RawLD::isWritable() const { char RawLD::getEntry(long away) const { - __u32 start = 0; - __u16 size = 0; + uint32_t start = 0; + uint16_t size = 0; char *idxbuf = 0; char retval = 0; @@ -195,8 +197,8 @@ long RawLD::getEntryCount() const { long RawLD::getEntryForKey(const char *key) const { - __u32 start, offset; - __u16 size; + uint32_t start, offset; + uint16_t size; char *buf = new char [ strlen(key) + 6 ]; strcpy(buf, key); diff --git a/src/modules/lexdict/rawld4/rawld4.cpp b/src/modules/lexdict/rawld4/rawld4.cpp index bfbe0cb5..8ce0ff35 100644 --- a/src/modules/lexdict/rawld4/rawld4.cpp +++ b/src/modules/lexdict/rawld4/rawld4.cpp @@ -21,6 +21,8 @@ * */ +#include <cstdint> + #include <fcntl.h> #include <filemgr.h> @@ -73,8 +75,8 @@ bool RawLD4::isWritable() const { char RawLD4::getEntry(long away) const { - __u32 start = 0; - __u32 size = 0; + uint32_t start = 0; + uint32_t size = 0; char *idxbuf = 0; char retval = 0; @@ -193,8 +195,8 @@ long RawLD4::getEntryCount() const { long RawLD4::getEntryForKey(const char *key) const { - __u32 start, offset; - __u32 size; + uint32_t start, offset; + uint32_t size; char *buf = new char [ strlen(key) + 6 ]; strcpy(buf, key); diff --git a/src/modules/swmodule.cpp b/src/modules/swmodule.cpp index e5589233..ce392846 100644 --- a/src/modules/swmodule.cpp +++ b/src/modules/swmodule.cpp @@ -23,6 +23,7 @@ */ +#include <cstdint> #include <vector> #include <swlog.h> @@ -556,7 +557,7 @@ ListKey &SWModule::search(const char *istr, int searchType, int flags, SWKey *sc Xapian::MSetIterator i; for (i = h.begin(); i != h.end(); ++i) { // cout << "Document ID " << *i << "\t"; - __u64 score = i.get_percent(); + uint64_t score = i.get_percent(); Xapian::Document doc = i.get_document(); *resultKey = doc.get_data().c_str(); #elif defined USELUCENE @@ -564,7 +565,7 @@ ListKey &SWModule::search(const char *istr, int searchType, int flags, SWKey *sc Document &doc = h->doc(i); // set a temporary verse key to this module position *resultKey = wcharToUTF8(doc.get(_T("key"))); //TODO Does a key always accept utf8? - __u64 score = (__u64)((__u32)(h->score(i)*100)); + uint64_t score = (uint64_t)((uint32_t)(h->score(i)*100)); #endif // check to see if it sets ok (within our bounds) and if not, skip diff --git a/tests/filtertest.cpp b/tests/filtertest.cpp index 03c86954..f1e5de67 100644 --- a/tests/filtertest.cpp +++ b/tests/filtertest.cpp @@ -20,6 +20,7 @@ * */ +#include <cstdint> #include <iostream> #include <swbuf.h> #include <filemgr.h> @@ -72,7 +73,7 @@ int main(int argc, char **argv) { /* // Example showing safe to cast to u16 stream unsigned int size = lineBuffer.size() / 2; - __u16 *wcharBuf = (__u16 *)lineBuffer.getRawData(); + uint16_t *wcharBuf = (uint16_t *)lineBuffer.getRawData(); for (unsigned int i = 0; i < size; ++i) { std::wcout << (wchar_t)wcharBuf[i]; // must cast for correct output and because wchar_t is different size on linux we couldn't declare out wcharBuf a wchar_t * } diff --git a/tests/utf8norm.cpp b/tests/utf8norm.cpp index 06143c43..1f2daf98 100644 --- a/tests/utf8norm.cpp +++ b/tests/utf8norm.cpp @@ -20,6 +20,7 @@ * */ +#include <cstdint> #include <iostream> #include <utilstr.h> #include <swbuf.h> @@ -67,7 +68,7 @@ int main(int argc, char **argv) { } const unsigned char *c = (const unsigned char *)filteredContents.getRawData(); // UTF-32 BOM - __u32 ch = 0xfeff; + uint32_t ch = 0xfeff; // write(STDOUT_FILENO, &ch, 4); while (c && *c) { ch = getUniCharFromUTF8(&c); -- 2.20.1 _______________________________________________ sword-devel mailing list: sword-devel@crosswire.org http://www.crosswire.org/mailman/listinfo/sword-devel Instructions to unsubscribe/change your settings at above page
