str_functions.h

Go to the documentation of this file.

/*
 * Copyright © 2008  Red Hat, Inc. All rights reserved.
 * Copyright © 2008  Ding-Yi Chen <dchen at redhat dot com>
 *
 * This file is part of the libUnihan Project.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA  02111-1307  USA
 */ 
 
#ifndef STR_FUNCTIONS_H_
#define STR_FUNCTIONS_H_
#include <string.h>
#include <glib.h>
#include <sys/types.h>
#include <regex.h>

#define CHAR_TO_UNSIGNEDINT(c)  (unsigned int)  ((int) c >=0)? c : c+256

#define CHAR_TO_UNSIGNEDCHAR(c) (unsigned char) ((int) c >=0)? c : c+256

typedef struct {
    GStringChunk *chunk; 
    GPtrArray *ptrArray; 
    GHashTable *hTable;  
    guint len;           
    size_t chunk_size_inital;  
} StringList;

StringList *stringList_new();

StringList *stringList_sized_new(size_t chunk_size, size_t element_count);

void stringList_clear(StringList *sList);

int stringList_find_string(StringList *sList,const char* str);


gboolean stringList_has_string(StringList *sList,const gchar* str);

gchar **stringList_to_charPointerPointer(StringList *sList);

const gchar *stringList_index(StringList *sList,guint index);

guint stringList_insert(StringList *sList, const gchar *str);

guint stringList_insert_const(StringList *sList, const gchar *str);

void stringList_free(StringList *sList);

// * @defgroup RegexResult_Match_Flags Regex substring match flags.
// * @{
// * @name Regex substring match flags.
// *
// * Bitwise regex substring match flags. Use bit operators to combine the flags.
// *
// * If none of the flags are given, by default, the output will be like:
// * <ol start="0">
// *   <li>ab,cd</li>
// *   <li>ab</li>
// *   <li>cd</li>
// *   <li>ef,gh</li>
// *   <li>ef</li>
// *   <li>gh</li>
// * </ol>
// *
// * If <code>REGEX_RESULT_ALLOW_OVERLAP</code> is given:
// * <ol start="0">
// *   <li>ab,cd</li>
// *   <li>ab</li>
// *   <li>cd</li>
// *   <li>cd,ef</li>
// *   <li>cd</li>
// *   <li>ef</li>
// *   <li>ef,gh</li>
// *   <li>ef</li>
// *   <li>gh</li>
// * </ol>
// *
// * If <code>REGEX_RESULT_EXCLUDE_MAJOR_MATCH</code> is given:
// * <ol start="0">
// *   <li>ab</li>
// *   <li>cd</li>
// *   <li>ef</li>
// *   <li>gh</li>
// * </ol>
// *
// * If <code>REGEX_RESULT_EXCLUDE_SUB_MATCH</code> is given:
// * <ol start="0">
// *   <li>ab,cd</li>
// *   <li>ef,gh</li>
// * </ol>

// * @{ 
// */

// * Flag to indicate that only the first result is needed.
// *
// * With this flag, results for \c aaa match \c a* will be \c aaa only.
// * Which is the original behavior of regexec()
// *
// * \note This flag overrides REGEX_RESULT_ALLOW_OVERLAP.
// */
//#define REGEX_RESULT_MATCH_ONCE 1
// * Flag to indicate that result substrings can be overlapped.
// *
// * With this flag, results for \c aaa match \c a* will be \c aaa, \c aa, \c a, but not empty string.
// * \note This flag has no effect if REGEX_RESULT_MATCH_ONCE is also set.
// */
//#define REGEX_RESULT_ALLOW_OVERLAP 2
// * Flag to indicate that major matches should be excluded.
// *
// * Major match means the matches of whole regex pattern.
// *
// * With this flag, results for \c abab matches \c a(b) will be \c b and  \c b, 
// * but not major match \c ab.
// */
//#define REGEX_RESULT_EXCLUDE_MAJOR_MATCH 4
// * Flag to indicate that sub matches should be excluded.
// *
// * Sub match means the matches of the parenthesized sub regex pattern.
// * With this flag, results for \c abab matches \c a(b) will be \c ab and  \c ab, but not \c b.
// */
//#define REGEX_RESULT_EXCLUDE_SUB_MATCH 8

// * @}
// * @}
// */

// * @defgroup RegexResult_Match_Functions Regex substring match functions.
// * @{
// * @name Regex substring match functions.
// *
// * These functions return a newly allocated StringList that holds a list of regex-matched substrings.
// * They add substring match functionality to regexec() from \c regex.h.
// *
// * Contract to the intuition, regexec() only matches once even if REG_NOSUB is not set in regcomp().
// * The so-called \i sub-match actually means the sub expressions enclosed by '()' in POSIX extended,
// * or '\(\)' in POSIX basic. 
// * For example, matches <code>ab,cd,ef,gh</code> with <code>([a-z]*),([a-z]*)</code> producing following output:
// * <ol start="0">
// *   <li>ab,cd</li>
// *   <li>ab</li>
// *   <li>cd</li>
// * </ol>
// * But not 
// * <ol start="3">
// *   <li>ef,gh</li>
// *   <li>ef</li>
// *   <li>gh</li>
// * </ol>
// * and so on.
// *
// * With regexResult_match_regex_t(), subsequence substrings are reachable.
// * The output can be filtered by using regex substring match flags.
// * @{
// */


// * The data structure that holds result of regex match.
// *
// */
//typedef struct{
//    StringList *resultList;  //!< List of string that actually match the pattern.
//    GArray *startOffsets;    //!< Start offset of the actual matched substrings.
//} RegexResult;

// * New a RegexResult instance.
// *
// * @return A newly allocated RegexResult instance.
// */
//RegexResult *regexResult_new();

// * Free a RegexResult instance.
// *
// * @param rResult RegexResult to be freed.
// */
//void regexResult_free(RegexResult *rResult);

// * Return regex-matched substrings.
// *
// * This function is a convenient wrap of regcomp() and 
// * regexResult_match_regex_t().
// * It compiles the regex_t from \a pattern using regcomp(), 
// * then call the regexResult_match_regex_t() for matched result.
// *
// * Use regexResult_free() to free the result.
// *
// * If the compilation fails, NULL will be returned.
// *
// * \note REG_NOSUB cannot be used in cflags, because regexec does not 
// * fill the data to array of \c regmatch_t.
// *
// * @param pattern Regex pattern.
// * @param str  String to be matched.
// * @param cflags flags to be passed to regcomp().
// * @param eflags eflag to be passed to regexec().
// * @param regexResultFlags RegexResult_Match_Flags
// * @return a newly allocated RegexResult, 
// * number of matches is indicated by RegexResult->resultList->len. len=0 if no matches;
// * NULL if \c pattern does not pass the compilation.
// *
// * @see RegexResult_Match_Functions 
// * @see RegexResult_Match_Flags
// * @see regexResult_match_regex_t()
// */
//RegexResult *regexResult_match(const gchar *pattern,const gchar *str, 
//        int cflags, int eflags, guint regexResultFlags);

// * Return regex-matched substrings, given an instance of regex_t.
// *
// * This function adds subsequence substring handling routine to regexec(), and 
// * returns a newly allocated StringList that holds a list of regex-matched substrings in \a str.
// * See RegexResult_Match for further explanation, and RegexResult_Match_Flags for output control.
// * 
// * @param preg Regex instance generate by regcomp().
// * @param str  String to be matched.
// * @param eflags eflag to be passed to regexec().
// * @param regexResultFlags RegexResult_Match_Flags
// * @return a newly allocated RegexResult, 
// * number of matches is indicated by RegexResult->resultList->len. len=0 if no matches;
// *
// * @see RegexResult_Match_Functions 
// * @see RegexResult_Match_Flags
// * @see regexResult_match()
// */
//RegexResult *regexResult_match_regex_t(
//        regex_t *preg,
//        const gchar *str, int eflags, guint regexResultFlags);

// * @}
// * @}
// */
//

gchar *string_formatted_combine(const gchar *format,StringList *sList,int *counter_ptr);

gchar *string_regex_formatted_combine_regex_t(const gchar *str, const regex_t *preg, const gchar *format, 
        int eflags, int *counter_ptr);

gchar *string_regex_formatted_combine(const gchar *str, const gchar *pattern, const gchar *format, 
        int cflags, int eflags, int *counter_ptr);


gchar *string_regex_replace_regex_t(const gchar *str, const regex_t *preg, const gchar *format, 
        int eflags, int *counter_ptr);

gchar *string_regex_replace(const gchar *str, const gchar *pattern, const gchar *format, 
        int cflags, int eflags, int *counter_ptr);

gchar*
initString(gchar *str);


gboolean
isEmptyString(const gchar *str);

void string_trim(gchar *str);


gchar*
subString(const gchar *str,int beginIndex, int length);

gchar*
subString_buffer(gchar *buf,const gchar *str,int beginIndex, int length);

gchar* string_append_c(gchar *str, const char ch,size_t length);

gboolean string_is_decomposed_fast(const gchar *str);

gchar* string_padding_left(const gchar *str, const gchar *padding_str, size_t length);

gchar* string_padding_right(const gchar *str, const gchar *padding_str, size_t length);

char* ucs4_to_utf8(gunichar ucs4_code);

gunichar* utf8_to_ucs4(const char* utf8_str);

gchar* utf8_concat_ucs4(gchar* utf8_str,gunichar ucs4_code);

int strcmp_unsigned_signed(const unsigned char *str1, const gchar *str2);

unsigned char *signedStr_to_unsignedStr(const gchar *str);

unsigned char *signedStr_to_unsignedStr_buffer(unsigned char *resultBuf, const gchar *str);

char *unsignedStr_to_signedStr(const unsigned char *str);

gchar *unsignedStr_to_signedStr_buffer(gchar* resultBuf, const unsigned char *str);


#endif /*STR_FUNCTIONS_H_*/

---