From mboxrd@z Thu Jan 1 00:00:00 1970 Path: news.gmane.io!.POSTED.blaine.gmane.org!not-for-mail From: Gregor Zattler Newsgroups: gmane.emacs.bugs Subject: bug#45246: 28.0.50; etags assertion error Date: Tue, 15 Dec 2020 00:38:40 +0100 Message-ID: <87k0tklzzz.fsf@no.workgroup> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="=-=-=" Injection-Info: ciao.gmane.io; posting-host="blaine.gmane.org:116.202.254.214"; logging-data="26939"; mail-complaints-to="usenet@ciao.gmane.io" To: 45246@debbugs.gnu.org Original-X-From: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane-mx.org@gnu.org Tue Dec 15 00:39:11 2020 Return-path: Envelope-to: geb-bug-gnu-emacs@m.gmane-mx.org Original-Received: from lists.gnu.org ([209.51.188.17]) by ciao.gmane.io with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.92) (envelope-from ) id 1koxQt-0006wC-Hu for geb-bug-gnu-emacs@m.gmane-mx.org; Tue, 15 Dec 2020 00:39:11 +0100 Original-Received: from localhost ([::1]:41156 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1koxQs-00051h-Kg for geb-bug-gnu-emacs@m.gmane-mx.org; Mon, 14 Dec 2020 18:39:10 -0500 Original-Received: from eggs.gnu.org ([2001:470:142:3::10]:41056) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1koxQk-00051K-RD for bug-gnu-emacs@gnu.org; Mon, 14 Dec 2020 18:39:02 -0500 Original-Received: from debbugs.gnu.org ([209.51.188.43]:43313) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_128_GCM_SHA256:128) (Exim 4.90_1) (envelope-from ) id 1koxQk-0007F9-JW for bug-gnu-emacs@gnu.org; Mon, 14 Dec 2020 18:39:02 -0500 Original-Received: from Debian-debbugs by debbugs.gnu.org with local (Exim 4.84_2) (envelope-from ) id 1koxQk-00013Q-F7 for bug-gnu-emacs@gnu.org; Mon, 14 Dec 2020 18:39:02 -0500 X-Loop: help-debbugs@gnu.org Resent-From: Gregor Zattler Original-Sender: "Debbugs-submit" Resent-CC: bug-gnu-emacs@gnu.org Resent-Date: Mon, 14 Dec 2020 23:39:02 +0000 Resent-Message-ID: Resent-Sender: help-debbugs@gnu.org X-GNU-PR-Message: report 45246 X-GNU-PR-Package: emacs X-Debbugs-Original-To: bug-gnu-emacs@gnu.org Original-Received: via spool by submit@debbugs.gnu.org id=B.16079891334035 (code B ref -1); Mon, 14 Dec 2020 23:39:02 +0000 Original-Received: (at submit) by debbugs.gnu.org; 14 Dec 2020 23:38:53 +0000 Original-Received: from localhost ([127.0.0.1]:54859 helo=debbugs.gnu.org) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1koxQa-000130-B8 for submit@debbugs.gnu.org; Mon, 14 Dec 2020 18:38:53 -0500 Original-Received: from lists.gnu.org ([209.51.188.17]:35290) by debbugs.gnu.org with esmtp (Exim 4.84_2) (envelope-from ) id 1koxQY-00012q-H3 for submit@debbugs.gnu.org; Mon, 14 Dec 2020 18:38:51 -0500 Original-Received: from eggs.gnu.org ([2001:470:142:3::10]:41022) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1koxQY-00050k-9g for bug-gnu-emacs@gnu.org; Mon, 14 Dec 2020 18:38:50 -0500 Original-Received: from mout.gmx.net ([212.227.17.22]:48871) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1koxQV-0007E9-1s for bug-gnu-emacs@gnu.org; Mon, 14 Dec 2020 18:38:50 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=gmx.net; s=badeba3b8450; t=1607989123; bh=lDR6Z4yz5MQTSSG3izNsgdDaWTI+Fss+DaHQO89nuLU=; h=X-UI-Sender-Class:From:To:Subject:Date; b=XSaMdYVyunzSp3fKo5AGnQ7c91de7Gf/sxHVvu2Z4bbcwBE8/uhZOSgTes/a61SMJ RIDX88GEFlYfo9gM4MwsRaXml9pYR1Cs+WvCJezCVinILQnlR54yx/OZ3/dnQxbHw8 sXtgM1txTLNZuZBLogR1IanyS4dcwvC5hRVoRKwQ= X-UI-Sender-Class: 01bb95c1-4bf8-414a-932a-4f6e2808ef9c Original-Received: from no.workgroup ([84.185.97.253]) by mail.gmx.com (mrgmx104 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MTRMi-1kh9xP2Z3s-00TiVM; Tue, 15 Dec 2020 00:38:43 +0100 X-Provags-ID: V03:K1:uW1BvHS3eOBsFmTS7nBUhRxIH8EzRoFQM+AulHrVLJ6X3m1eoKj kYA/qv4iH0zlvN+PxfSF307hB9fI+1bzyV8j8RquIda6EV1EZdDCB2XmQf8Mj0ZSHclfA2d TG6kcg6o46E6aYmvyOeVf3RdebsmTP4ycTxz5/ZLSnaVT0I+/Ad8bjGgl9LBGHXQocWeUU9 waUOfgh2UJc/i7l22ziNA== X-UI-Out-Filterresults: notjunk:1;V03:K0:A/1Sv1pHQxA=:R3xLaUxJdwcy03aUW1TSzk RQ+IDna32YeqBRusLbWRpLHajGaXC4QwuGGectXEMELJuafQV+RguHb+Lu6V/WgpIwLaS9f0e wtpukfjB2QMN7CJtgS0sVuDMLvWWjDqT54txgLg1R9A0n+uixB0oFM292diFuGfDkt0h2F/TJ kL/n4RuejlZeiKV53A3SCDv4ys5JRQE/v70mGKhJE/DLkxcInVClslhB8NkxShVKktp+Rrng7 1n9m+xRTqzu/+gEiXkVBCSxObCB/EA++v33tITaIOvqQY2YDAhae3PCI+YT7G/9oGYgE7xkjF nyu/LagDr+kB0htssxDHOpXaE0Z2+L7Ux+dIbfxVbMbv4FIYTw1X3gMYCnGWaywIsWQWPIYIz NOnntrAO/fLxl82JK2vij2gR4FMifJSY9VPfqW4VReZvBJplNsNDCuiL/zt6vNDiuM5oGaZvY twTBae2eQdlBBkRURofGM+Uvt7VgNTV8Te0JqCRJizXlxb2XFkjBdxPhIQGuFqGk5LY/kA9Sm FLuCT37+n9FtkqRhwmIqb1tauOHmzK1z5I+mMNIOenTmlS9B9xN3uZZV7YvkVLp8gTC3xirpd CQoSkoJlTccqchszDtVzW4IifrUbblMkr32rnh7gHQOdmj6Gdoub5hMWfp4WUK4PIQD0zpqdU vzJtW7zuHOTtDLHrUiTQPXkSpCA1J/uM2Ali9ASDrstOV3/I0/DR7KCc9ksMGgLo/+8KudTDl e9zJkG0kaxI7aWARQoOORr4aZnT1dMNxG/nXkwtyHoH6qcKnd1R3NIwpOiC9N4YXS6+AOSCU Received-SPF: pass client-ip=212.227.17.22; envelope-from=grfz@gmx.de; helo=mout.gmx.net X-Spam_score_int: -25 X-Spam_score: -2.6 X-Spam_bar: -- X-Spam_report: (-2.6 / 5.0 requ) BAYES_00=-1.9, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, FREEMAIL_FROM=0.001, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H2=-0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: debbugs-submit@debbugs.gnu.org X-Mailman-Version: 2.1.18 Precedence: list X-BeenThere: bug-gnu-emacs@gnu.org List-Id: "Bug reports for GNU Emacs, the Swiss army knife of text editors" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: bug-gnu-emacs-bounces+geb-bug-gnu-emacs=m.gmane-mx.org@gnu.org Original-Sender: "bug-gnu-emacs" Xref: news.gmane.io gmane.emacs.bugs:196120 Archived-At: --=-=-= Content-Type: text/plain Dear emacs developers, I use emacs Configured using: 'configure -C --with-file-notification=inotify --with-cairo --without-toolkit-scroll-bars --with-x-toolkit=lucid --with-sound=yes --without-gconf --with-mailutils --with-x=yes --enable-checking=yes --enable-check-lisp-object-type=yes --with-nativecomp 'CFLAGS=-g -O2 -fdebug-prefix-map=/home/grfz/src/emacs-feature_native-comp=. -fstack-protector-strong -Wformat -Werror=format-security -Wall -fno-pie' 'CPPFLAGS=-Wdate-time -D_FORTIFY_SOURCE=2 ' 'LDFLAGS=-Wl,-z,relro -no-pie'' and I get an assertion error when executing the following line: ~/src$ find . -type f -print0 | egrep -zZ -- '(\.el|\.c|\.h)(\.gz)?$' | xargs -0IXXXXX sh -c "/home/grfz/src/emacs-master/lib-src/etags XXXXX || echo XXXXX" etags: etags.c:4153: C_entries: Assertion `bracelev == typdefbracelev' failed. Aborted ./xapian-core-1.4.17/include/xapian/unicode.h etags: etags.c:4153: C_entries: Assertion `bracelev == typdefbracelev' failed. Aborted ./xapian-core-1.4.17/debian/tmp/usr/include/xapian/unicode.h etags: etags.c:4153: C_entries: Assertion `bracelev == typdefbracelev' failed. Aborted ./xapian-core-1.4.17/debian/libxapian-dev/usr/include/xapian/unicode.h The file in question is attached to this email. I do not get an assertion error if I use /usr/bin/etags.emacs --version ./xapian-core-1.4.17/include/xapian/unicode.h This etags binary is from the debian buster distribution. Thanks for your attention, Gregor --=-=-= Content-Type: text/plain Content-Disposition: inline; filename=unicode.h /** @file unicode.h * @brief Unicode and UTF-8 related classes and functions. */ /* Copyright (C) 2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2019 Olly Betts * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #ifndef XAPIAN_INCLUDED_UNICODE_H #define XAPIAN_INCLUDED_UNICODE_H #if !defined XAPIAN_IN_XAPIAN_H && !defined XAPIAN_LIB_BUILD # error Never use directly; include instead. #endif #include #include #include namespace Xapian { /** An iterator which returns Unicode character values from a UTF-8 encoded * string. */ class XAPIAN_VISIBILITY_DEFAULT Utf8Iterator { const unsigned char* p; const unsigned char* end; mutable unsigned seqlen; bool XAPIAN_NOTHROW(calculate_sequence_length() const); unsigned get_char() const; Utf8Iterator(const unsigned char* p_, const unsigned char* end_, unsigned seqlen_) : p(p_), end(end_), seqlen(seqlen_) { } public: /** Return the raw const char* pointer for the current position. */ const char* raw() const { return reinterpret_cast(p ? p : end); } /** Return the number of bytes left in the iterator's buffer. */ size_t left() const { return p ? end - p : 0; } /** Assign a new string to the iterator. * * The iterator will forget the string it was iterating through, and * return characters from the start of the new string when next called. * The string is not copied into the iterator, so it must remain valid * while the iteration is in progress. * * @param p_ A pointer to the start of the string to read. * * @param len The length of the string to read. */ void assign(const char* p_, size_t len) { if (len) { p = reinterpret_cast(p_); end = p + len; seqlen = 0; } else { p = NULL; } } /** Assign a new string to the iterator. * * The iterator will forget the string it was iterating through, and * return characters from the start of the new string when next called. * The string is not copied into the iterator, so it must remain valid * while the iteration is in progress. * * @param s The string to read. Must not be modified while the iteration * is in progress. */ void assign(const std::string& s) { assign(s.data(), s.size()); } /** Create an iterator given a pointer to a null terminated string. * * The iterator will return characters from the start of the string when * next called. The string is not copied into the iterator, so it must * remain valid while the iteration is in progress. * * @param p_ A pointer to the start of the null terminated string to read. */ explicit Utf8Iterator(const char* p_); /** Create an iterator given a pointer and a length. * * The iterator will return characters from the start of the string when * next called. The string is not copied into the iterator, so it must * remain valid while the iteration is in progress. * * @param p_ A pointer to the start of the string to read. * * @param len The length of the string to read. */ Utf8Iterator(const char* p_, size_t len) { assign(p_, len); } /** Create an iterator given a string. * * The iterator will return characters from the start of the string when * next called. The string is not copied into the iterator, so it must * remain valid while the iteration is in progress. * * @param s The string to read. Must not be modified while the iteration * is in progress. */ Utf8Iterator(const std::string& s) { assign(s.data(), s.size()); } /** Create an iterator which is at the end of its iteration. * * This can be compared to another iterator to check if the other iterator * has reached its end. */ XAPIAN_NOTHROW(Utf8Iterator()) : p(NULL), end(0), seqlen(0) { } /** Get the current Unicode character value pointed to by the iterator. * * If an invalid UTF-8 sequence is encountered, then the byte values * comprising it are returned until valid UTF-8 or the end of the input is * reached. * * Returns unsigned(-1) if the iterator has reached the end of its buffer. */ unsigned XAPIAN_NOTHROW(operator*() const) XAPIAN_PURE_FUNCTION; /** @private @internal Get the current Unicode character * value pointed to by the iterator. * * If an invalid UTF-8 sequence is encountered, then the byte values * comprising it are returned with the top bit set (so the caller can * differentiate these from the same values arising from valid UTF-8) * until valid UTF-8 or the end of the input is reached. * * Returns unsigned(-1) if the iterator has reached the end of its buffer. */ unsigned XAPIAN_NOTHROW(strict_deref() const) XAPIAN_PURE_FUNCTION; /** Move forward to the next Unicode character. * * @return An iterator pointing to the position before the move. */ Utf8Iterator operator++(int) { // If we've not calculated seqlen yet, do so. if (seqlen == 0) calculate_sequence_length(); const unsigned char* old_p = p; unsigned old_seqlen = seqlen; p += seqlen; if (p == end) p = NULL; seqlen = 0; return Utf8Iterator(old_p, end, old_seqlen); } /** Move forward to the next Unicode character. * * @return A reference to this object. */ Utf8Iterator& operator++() { if (seqlen == 0) calculate_sequence_length(); p += seqlen; if (p == end) p = NULL; seqlen = 0; return *this; } /** Test two Utf8Iterators for equality. * * @param other The Utf8Iterator to compare this one with. * @return true iff the iterators point to the same position. */ bool XAPIAN_NOTHROW(operator==(const Utf8Iterator& other) const) { return p == other.p; } /** Test two Utf8Iterators for inequality. * * @param other The Utf8Iterator to compare this one with. * @return true iff the iterators do not point to the same position. */ bool XAPIAN_NOTHROW(operator!=(const Utf8Iterator& other) const) { return p != other.p; } /// We implement the semantics of an STL input_iterator. //@{ typedef std::input_iterator_tag iterator_category; typedef unsigned value_type; typedef size_t difference_type; typedef const unsigned* pointer; typedef const unsigned& reference; //@} }; /// Functions associated with handling Unicode characters. namespace Unicode { /** Each Unicode character is in exactly one of these categories. * * The Unicode standard calls this the "General Category", and uses a * "Major, minor" convention to derive a two letter code. */ typedef enum { UNASSIGNED, /**< Other, not assigned (Cn) */ UPPERCASE_LETTER, /**< Letter, uppercase (Lu) */ LOWERCASE_LETTER, /**< Letter, lowercase (Ll) */ TITLECASE_LETTER, /**< Letter, titlecase (Lt) */ MODIFIER_LETTER, /**< Letter, modifier (Lm) */ OTHER_LETTER, /**< Letter, other (Lo) */ NON_SPACING_MARK, /**< Mark, nonspacing (Mn) */ ENCLOSING_MARK, /**< Mark, enclosing (Me) */ COMBINING_SPACING_MARK, /**< Mark, spacing combining (Mc) */ DECIMAL_DIGIT_NUMBER, /**< Number, decimal digit (Nd) */ LETTER_NUMBER, /**< Number, letter (Nl) */ OTHER_NUMBER, /**< Number, other (No) */ SPACE_SEPARATOR, /**< Separator, space (Zs) */ LINE_SEPARATOR, /**< Separator, line (Zl) */ PARAGRAPH_SEPARATOR, /**< Separator, paragraph (Zp) */ CONTROL, /**< Other, control (Cc) */ FORMAT, /**< Other, format (Cf) */ PRIVATE_USE, /**< Other, private use (Co) */ SURROGATE, /**< Other, surrogate (Cs) */ CONNECTOR_PUNCTUATION, /**< Punctuation, connector (Pc) */ DASH_PUNCTUATION, /**< Punctuation, dash (Pd) */ OPEN_PUNCTUATION, /**< Punctuation, open (Ps) */ CLOSE_PUNCTUATION, /**< Punctuation, close (Pe) */ INITIAL_QUOTE_PUNCTUATION, /**< Punctuation, initial quote (Pi) */ FINAL_QUOTE_PUNCTUATION, /**< Punctuation, final quote (Pf) */ OTHER_PUNCTUATION, /**< Punctuation, other (Po) */ MATH_SYMBOL, /**< Symbol, math (Sm) */ CURRENCY_SYMBOL, /**< Symbol, currency (Sc) */ MODIFIER_SYMBOL, /**< Symbol, modified (Sk) */ OTHER_SYMBOL /**< Symbol, other (So) */ } category; namespace Internal { /** @private @internal Extract the information about a character from the * Unicode character tables. * * Characters outside of the Unicode range (i.e. ch >= 0x110000) are * treated as UNASSIGNED with no case variants. */ XAPIAN_VISIBILITY_DEFAULT int XAPIAN_NOTHROW(get_character_info(unsigned ch)) XAPIAN_CONST_FUNCTION; /** @private @internal Extract how to convert the case of a Unicode * character from its info. */ inline int get_case_type(int info) { return ((info & 0xe0) >> 5); } /** @private @internal Extract the category of a Unicode character from its * info. */ inline category get_category(int info) { return static_cast(info & 0x1f); } /** @private @internal Extract the delta to use for case conversion of a * character from its info. */ inline int get_delta(int info) { /* It's implementation defined if sign extension happens when right * shifting a signed int, although in practice sign extension is what * most compilers implement. * * Some compilers are smart enough to spot common idioms for sign * extension, but not all (e.g. GCC < 7 doesn't spot the one used * below), so check what the implementation-defined behaviour is with * a constant conditional which should get optimised away. * * We use the ternary operator here to avoid various compiler * warnings which writing this as an `if` results in. */ return ((-1 >> 1) == -1 ? // Right shift sign-extends. info >> 8 : // Right shift shifts in zeros so bitwise-not before and after // the shift for negative values. (info >= 0) ? (info >> 8) : (~(~info >> 8))); } } /** Convert a single non-ASCII Unicode character to UTF-8. * * This is intended mainly as a helper method for to_utf8(). * * @param ch The character (which must be > 128) to write to @a buf. * @param buf The buffer to write the character to - it must have * space for (at least) 4 bytes. * * @return The length of the resultant UTF-8 character in bytes. */ XAPIAN_VISIBILITY_DEFAULT unsigned nonascii_to_utf8(unsigned ch, char* buf); /** Convert a single Unicode character to UTF-8. * * @param ch The character to write to @a buf. * @param buf The buffer to write the character to - it must have * space for (at least) 4 bytes. * * @return The length of the resultant UTF-8 character in bytes. */ inline unsigned to_utf8(unsigned ch, char* buf) { if (ch < 128) { *buf = static_cast(ch); return 1; } return Xapian::Unicode::nonascii_to_utf8(ch, buf); } /** Append the UTF-8 representation of a single Unicode character to a * std::string. */ inline void append_utf8(std::string& s, unsigned ch) { char buf[4]; s.append(buf, to_utf8(ch, buf)); } /// Return the category which a given Unicode character falls into. inline category get_category(unsigned ch) { return Internal::get_category(Internal::get_character_info(ch)); } /// Test if a given Unicode character is "word character". inline bool is_wordchar(unsigned ch) { const unsigned int WORDCHAR_MASK = (1 << Xapian::Unicode::UPPERCASE_LETTER) | (1 << Xapian::Unicode::LOWERCASE_LETTER) | (1 << Xapian::Unicode::TITLECASE_LETTER) | (1 << Xapian::Unicode::MODIFIER_LETTER) | (1 << Xapian::Unicode::OTHER_LETTER) | (1 << Xapian::Unicode::NON_SPACING_MARK) | (1 << Xapian::Unicode::ENCLOSING_MARK) | (1 << Xapian::Unicode::COMBINING_SPACING_MARK) | (1 << Xapian::Unicode::DECIMAL_DIGIT_NUMBER) | (1 << Xapian::Unicode::LETTER_NUMBER) | (1 << Xapian::Unicode::OTHER_NUMBER) | (1 << Xapian::Unicode::CONNECTOR_PUNCTUATION); return ((WORDCHAR_MASK >> get_category(ch)) & 1); } /// Test if a given Unicode character is a whitespace character. inline bool is_whitespace(unsigned ch) { const unsigned int WHITESPACE_MASK = (1 << Xapian::Unicode::CONTROL) | // For TAB, CR, LF, FF. (1 << Xapian::Unicode::SPACE_SEPARATOR) | (1 << Xapian::Unicode::LINE_SEPARATOR) | (1 << Xapian::Unicode::PARAGRAPH_SEPARATOR); return ((WHITESPACE_MASK >> get_category(ch)) & 1); } /// Test if a given Unicode character is a currency symbol. inline bool is_currency(unsigned ch) { return (get_category(ch) == Xapian::Unicode::CURRENCY_SYMBOL); } /// Convert a Unicode character to lowercase. inline unsigned tolower(unsigned ch) { int info = Xapian::Unicode::Internal::get_character_info(ch); if (!(Internal::get_case_type(info) & 2)) return ch; return ch + Internal::get_delta(info); } /// Convert a Unicode character to uppercase. inline unsigned toupper(unsigned ch) { int info = Xapian::Unicode::Internal::get_character_info(ch); if (!(Internal::get_case_type(info) & 4)) return ch; return ch - Internal::get_delta(info); } /// Convert a UTF-8 std::string to lowercase. inline std::string tolower(const std::string& term) { std::string result; result.reserve(term.size()); for (Utf8Iterator i(term); i != Utf8Iterator(); ++i) { append_utf8(result, tolower(*i)); } return result; } /// Convert a UTF-8 std::string to uppercase. inline std::string toupper(const std::string& term) { std::string result; result.reserve(term.size()); for (Utf8Iterator i(term); i != Utf8Iterator(); ++i) { append_utf8(result, toupper(*i)); } return result; } } } #endif // XAPIAN_INCLUDED_UNICODE_H --=-=-=--