AbiWord: ut_string.h Source File

00001 /* AbiSource Program Utilities
00002  * Copyright (C) 1998,1999 AbiSource, Inc.
00003  *
00004  * This program is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU General Public License
00006  * as published by the Free Software Foundation; either version 2
00007  * of the License, or (at your option) any later version.
00008  *
00009  * This program is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  * GNU General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU General Public License
00015  * along with this program; if not, write to the Free Software
00016  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
00017  * 02111-1307, USA.
00018  */
00019 
00020 
00021 #ifndef UT_STRING_H
00022 #define UT_STRING_H
00023 
00024 #include <map>
00025 #include <string>
00026 #include <string.h>
00027 
00028 /* pre-emptive dismissal; ut_types.h is needed by just about everything,
00029  * so even if it's commented out in-file that's still a lot of work for
00030  * the preprocessor to do...
00031  */
00032 #ifndef UT_TYPES_H
00033 #include "ut_types.h"
00034 #endif
00035 
00036 class UT_GrowBuf;
00037 
00038 G_BEGIN_DECLS
00039 
00040 // this function allocates (and returns a pointer to) new memory for the new string
00041 ABI_EXPORT bool  UT_XML_cloneNoAmpersands(gchar *& rszDest, const gchar * szSource);
00042 // This function uses a static buffer to do the translation
00043 ABI_EXPORT gchar *  UT_XML_transNoAmpersands(const gchar * szSource);
00044 
00045 ABI_EXPORT void  UT_decodeUTF8string(const gchar * p, UT_uint32 len, UT_GrowBuf * pResult);
00046 
00047 ABI_EXPORT bool  UT_isValidXML(const char *s);
00048 ABI_EXPORT bool  UT_validXML(char * s);
00049 
00050 /* ABI_EXPORT gchar *  UT_decodeXMLstring(gchar *pcIn);
00051  * This has moved to ut_xml.cpp as UT_XML::decode ()
00052  */
00053 
00054 ABI_EXPORT bool  UT_isSmartQuotableCharacter(UT_UCSChar c);
00055 ABI_EXPORT bool  UT_isSmartQuotedCharacter(UT_UCSChar c);
00056 
00058 //
00059 //  UCS-2 string (UT_UCS2Char)
00060 //
00061 //  String is built of 16-bit units (words)
00062 //
00063 //  TODO: Is this really UCS-2 or UTF-16?
00064 //  TODO:  meaning, does it support surrogates or is it intended to
00065 //  TODO:  support them at any time in the future?
00066 //  TODO: Correctly, UCS-2 does not support surrogates and UTF-16 does.
00067 //  TODO: BUT Microsoft calls their native Unicode encoding UCS-2
00068 //  TODO:  while it supports surrogates and is thus really UTF-16.
00069 //  TODO: Surrogates are Unicode characters with codepoints above
00070 //  TODO:  65535 which cannot therefore fit into a 2-byte word.
00071 //  TODO: This means that TRUE UCS-2 is a single-word encoding and
00072 //  TODO:  UTF-16 is a multi-word encoding.
00073 //
00074 //  NOTE: We shouldn't actually need 16-bit strings anymore since
00075 //  NOTE:  AbiWord is now fully converted to using 32-bit Unicode
00076 //  NOTE:  internally. The only possible needs for this is for
00077 //  NOTE:  Windows GUI, filesystem and API functions where applicable;
00078 //  NOTE:  and perhaps some file formats or external libraries
00079 //
00081 
00082 #ifdef ENABLE_UCS2_STRINGS
00083 
00084 #define UT_UCS2_isdigit(x)  (((x) >= '0') && ((x) <= '9'))  // TODO: make UNICODE-wise
00085 
00086 /*these are unicode-safe*/
00087 ABI_EXPORT bool  UT_UCS2_isupper(UT_UCS2Char c);
00088 ABI_EXPORT bool  UT_UCS2_islower(UT_UCS2Char c);
00089 ABI_EXPORT bool  UT_UCS2_isalpha(UT_UCS2Char c);
00090 ABI_EXPORT bool  UT_UCS2_isSentenceSeparator(UT_UCS2Char c);
00091 #define UT_UCS2_isalnum(x)  (UT_UCS2_isalpha(x) || UT_UCS2_isdigit(x)) // HACK: not UNICODE-safe
00092 ABI_EXPORT bool UT_UCS2_isspace(UT_UCS2Char c);
00093 #define UT_UCS2_ispunct(x)   ((!UT_UCS2_isspace(x)  &&  !UT_UCS2_isalnum(x)  &&  (x)>' '))  // HACK: not UNICODE safe
00094 
00095 // the naming convention has deviated from the above.  it's kind
00096 // of a mutant libc/C++ naming convention.
00097 ABI_EXPORT UT_UCS2Char *     UT_UCS2_strstr(const UT_UCS2Char * phaystack, const UT_UCS2Char * pneedle);
00098 ABI_EXPORT UT_sint32         UT_UCS2_strcmp(const UT_UCS2Char* left, const UT_UCS2Char* right);
00099 ABI_EXPORT UT_UCS2Char *     UT_UCS2_stristr(const UT_UCS2Char * phaystack, const UT_UCS2Char * pneedle);
00100 ABI_EXPORT UT_UCS2Char *     UT_UCS2_strcpy(UT_UCS2Char * dest, const UT_UCS2Char * src);
00101 ABI_EXPORT UT_UCS2Char *     UT_UCS2_strcpy_char(UT_UCS2Char * dest, const char * src);
00102 ABI_EXPORT char *            UT_UCS2_strcpy_to_char(char * dest, const UT_UCS2Char * src);
00103 ABI_EXPORT bool          UT_UCS2_cloneString(UT_UCS2Char ** dest, const UT_UCS2Char * src);
00104 ABI_EXPORT bool          UT_UCS2_cloneString_char(UT_UCS2Char ** dest, const char * src);
00105 ABI_EXPORT UT_UCS2Char *     UT_UCS2_strncpy(UT_UCS2Char * dest, const UT_UCS2Char * src, UT_uint32 n);
00106 ABI_EXPORT UT_UCS2Char *     UT_UCS2_strnrev(UT_UCS2Char * dest, UT_uint32 n);
00107 
00108 ABI_EXPORT UT_UCS2Char       UT_UCS2_tolower(UT_UCS2Char c);
00109 ABI_EXPORT UT_UCS2Char       UT_UCS2_toupper(UT_UCS2Char c);
00110 
00111 #endif
00112 
00113 // Don't ifdef this one out since MSWord importer uses it
00114 
00115 ABI_EXPORT UT_uint32         UT_UCS2_strlen(const UT_UCS2Char * string);
00116 
00118 //
00119 //  UCS-4 string (UT_UCS4Char)
00120 //
00121 //  String is built of 32-bit units (longs)
00122 //
00123 //  NOTE: Ambiguity between UCS-2 and UTF-16 above makes no difference
00124 //  NOTE:  in the case of UCS-4 and UTF-32 since they really are
00125 //  NOTE:  identical
00126 //
00128 
00129 /*these are unicode-safe*/
00130 ABI_EXPORT bool  UT_UCS4_isupper(UT_UCS4Char c);
00131 ABI_EXPORT bool  UT_UCS4_islower(UT_UCS4Char c);
00132 ABI_EXPORT bool  UT_UCS4_isalpha(UT_UCS4Char c);
00133 ABI_EXPORT bool  UT_UCS4_isSentenceSeparator(UT_UCS4Char c);
00134 #define UT_UCS4_isalnum(x)  (UT_UCS4_isalpha(x) || UT_UCS4_isdigit(x)) // HACK: not UNICODE-safe
00135 ABI_EXPORT bool UT_UCS4_isspace(UT_UCS4Char c);
00136 #define UT_UCS4_ispunct(x)   ((!UT_UCS4_isspace(x)  &&  !UT_UCS4_isalnum(x)  &&  (x)>' '))  // HACK: not UNICODE safe
00137 
00138 #define UT_UCS4_isdigit(x)  (((x) >= '0') && ((x) <= '9'))  // TODO: make UNICODE-wise
00139 
00140 // the naming convention has deviated from the above.  it's kind
00141 // of a mutant libc/C++ naming convention.
00142 ABI_EXPORT UT_sint32         UT_UCS4_strcmp(const UT_UCS4Char* left, const UT_UCS4Char* right);
00143 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strstr(const UT_UCS4Char * phaystack, const UT_UCS4Char * pneedle);
00144 ABI_EXPORT UT_UCS4Char *     UT_UCS4_stristr(const UT_UCS4Char * phaystack, const UT_UCS4Char * pneedle);
00145 ABI_EXPORT UT_uint32         UT_UCS4_strlen(const UT_UCS4Char * string);
00146 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strcpy(UT_UCS4Char * dest, const UT_UCS4Char * src);
00147 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strcpy_char(UT_UCS4Char * dest, const char * src);
00148 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strncpy_char(UT_UCS4Char * dest, const char * src, int);
00149 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strcpy_utf8_char(UT_UCS4Char * dest, const char * src);
00150 ABI_EXPORT char *            UT_UCS4_strcpy_to_char(char * dest, const UT_UCS4Char * src);
00151 ABI_EXPORT char *            UT_UCS4_strncpy_to_char(char * dest, const UT_UCS4Char * src, int);
00152 ABI_EXPORT bool              UT_UCS4_cloneString(UT_UCS4Char ** dest, const UT_UCS4Char * src);
00153 ABI_EXPORT bool              UT_UCS4_cloneString_char(UT_UCS4Char ** dest, const char * src);
00154 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strncpy(UT_UCS4Char * dest, const UT_UCS4Char * src, UT_uint32 n);
00155 ABI_EXPORT UT_UCS4Char *     UT_UCS4_strnrev(UT_UCS4Char * dest, UT_uint32 n);
00156 
00157 ABI_EXPORT UT_UCS4Char       UT_UCS4_tolower(UT_UCS4Char c);
00158 ABI_EXPORT UT_UCS4Char       UT_UCS4_toupper(UT_UCS4Char c);
00159 
00160 
00161 ABI_EXPORT void UT_parse_attributes(const char * attributes,
00162                                     std::map<std::string, std::string> & map);
00163 ABI_EXPORT void UT_parse_properties(const char * props,
00164                                     std::map<std::string, std::string> & map);
00165 
00166 
00167 #ifdef WIN32
00168 #define snprintf _snprintf
00169 
00170 #define _(String) (String)
00171 #define N_(String) (String)
00172 
00173 #endif /* WIN32 */
00174 
00175 #if defined (SNPRINTF_MISSING)
00176   extern int snprintf(char *str, size_t size, const  char  *format, ...);
00177 #endif
00178 
00179 /*
00180  this one prints floating point value but using dot as fractional serparator
00181  independent of the current locale's settings.
00182 */
00183 ABI_EXPORT const char*  std_size_string(float f);
00184 
00185 
00186 #include <fribidi.h>
00187 
00188 typedef FriBidiCharType UT_BidiCharType;
00189 
00190 #define UT_BIDI_LTR FRIBIDI_TYPE_LTR
00191 #define UT_BIDI_RTL FRIBIDI_TYPE_RTL
00192 #define UT_BIDI_WS FRIBIDI_TYPE_WS
00193 #define UT_BIDI_EN FRIBIDI_TYPE_EN
00194 #define UT_BIDI_ES FRIBIDI_TYPE_ES
00195 #define UT_BIDI_ET FRIBIDI_TYPE_ET
00196 #define UT_BIDI_AN FRIBIDI_TYPE_AN
00197 #define UT_BIDI_CS FRIBIDI_TYPE_CS
00198 #define UT_BIDI_BS FRIBIDI_TYPE_BS
00199 #define UT_BIDI_SS FRIBIDI_TYPE_SS
00200 #define UT_BIDI_AL FRIBIDI_TYPE_AL
00201 #define UT_BIDI_NSM FRIBIDI_TYPE_NSM
00202 #define UT_BIDI_RLE FRIBIDI_TYPE_RLE
00203 #define UT_BIDI_LRE FRIBIDI_TYPE_LRE
00204 #define UT_BIDI_LRO FRIBIDI_TYPE_LRO
00205 #define UT_BIDI_RLO FRIBIDI_TYPE_RLO
00206 #define UT_BIDI_PDF FRIBIDI_TYPE_PDF
00207 #define UT_BIDI_ON FRIBIDI_TYPE_ON
00208 
00209 
00210 #define UT_BIDI_UNSET FRIBIDI_TYPE_UNSET
00211 #define UT_BIDI_IGNORE FRIBIDI_TYPE_IGNORE
00212 
00213 #define UT_BIDI_IS_STRONG FRIBIDI_IS_STRONG
00214 #define UT_BIDI_IS_WEAK FRIBIDI_IS_WEAK
00215 #define UT_BIDI_IS_NUMBER FRIBIDI_IS_NUMBER
00216 #define UT_BIDI_IS_RTL FRIBIDI_IS_RTL
00217 #define UT_BIDI_IS_NEUTRAL FRIBIDI_IS_NEUTRAL
00218 #define UT_BIDI_IS_LETTER FRIBIDI_IS_LETTER
00219 #define UT_BIDI_IS_NSM(x) ((x) & FRIBIDI_MASK_NSM)
00220 
00221 
00222 ABI_EXPORT UT_BidiCharType UT_bidiGetCharType(UT_UCS4Char c);
00223 
00224 ABI_EXPORT bool            UT_bidiMapLog2Vis(const UT_UCS4Char * pStrIn, UT_uint32 len, UT_BidiCharType baseDir,
00225                                              UT_uint32 *pL2V, UT_uint32 * pV2L, UT_Byte * pEmbed);
00226 
00227 ABI_EXPORT bool            UT_bidiReorderString(const UT_UCS4Char * pStrIn, UT_uint32 len, UT_BidiCharType baseDir,
00228                                                 UT_UCS4Char * pStrOut);
00229 
00230 
00231 ABI_EXPORT bool            UT_bidiGetMirrorChar(UT_UCS4Char c, UT_UCS4Char &mc);
00232 
00233 G_END_DECLS
00234 
00235 #endif /* UT_STRING_H */