X-Git-Url: http://lists.indexdata.com/cgi-bin?a=blobdiff_plain;f=src%2Ficu_I18N.c;h=74b42da2b4a36fe60fbb44e258e54a7560144833;hb=f0b1f63415168bbc1a12f0eb3a1f03511b82c1ec;hp=de8487418822a4420c99ea9f17044d4f77577c58;hpb=765b94caaa93566a9792019ec5d2bf56fc8100a3;p=yaz-moved-to-github.git diff --git a/src/icu_I18N.c b/src/icu_I18N.c index de84874..74b42da 100644 --- a/src/icu_I18N.c +++ b/src/icu_I18N.c @@ -1,8 +1,11 @@ -/* - * Copyright (C) 1995-2007, Index Data ApS +/* This file is part of the YAZ toolkit. + * Copyright (C) 1995-2009 Index Data * See the file LICENSE for details. - * - * $Id: icu_I18N.c,v 1.21 2007-11-30 11:43:47 adam Exp $ + */ + +/** + * \file icu_I18N.c + * \brief ICU utilities */ #if HAVE_CONFIG_H @@ -27,12 +30,9 @@ #include /* some more string fcns*/ #include /* char names */ - - #include - -int icu_check_status (UErrorCode status) +int icu_check_status(UErrorCode status) { if (U_FAILURE(status)) { @@ -40,11 +40,8 @@ int icu_check_status (UErrorCode status) return 0; } return 1; - } - - struct icu_buf_utf16 * icu_buf_utf16_create(size_t capacity) { struct icu_buf_utf16 * buf16 @@ -54,7 +51,8 @@ struct icu_buf_utf16 * icu_buf_utf16_create(size_t capacity) buf16->utf16_len = 0; buf16->utf16_cap = 0; - if (capacity > 0){ + if (capacity > 0) + { buf16->utf16 = (UChar *) xmalloc(sizeof(UChar) * capacity); buf16->utf16[0] = (UChar) 0; buf16->utf16_cap = capacity; @@ -64,7 +62,8 @@ struct icu_buf_utf16 * icu_buf_utf16_create(size_t capacity) struct icu_buf_utf16 * icu_buf_utf16_clear(struct icu_buf_utf16 * buf16) { - if (buf16){ + if (buf16) + { if (buf16->utf16) buf16->utf16[0] = (UChar) 0; buf16->utf16_len = 0; @@ -78,7 +77,8 @@ struct icu_buf_utf16 * icu_buf_utf16_resize(struct icu_buf_utf16 * buf16, if (!buf16) return 0; - if (capacity > 0){ + if (capacity > 0) + { if (0 == buf16->utf16) buf16->utf16 = (UChar *) xmalloc(sizeof(UChar) * capacity); else @@ -88,7 +88,8 @@ struct icu_buf_utf16 * icu_buf_utf16_resize(struct icu_buf_utf16 * buf16, icu_buf_utf16_clear(buf16); buf16->utf16_cap = capacity; } - else { + else + { xfree(buf16->utf16); buf16->utf16 = 0; buf16->utf16_len = 0; @@ -102,8 +103,7 @@ struct icu_buf_utf16 * icu_buf_utf16_resize(struct icu_buf_utf16 * buf16, struct icu_buf_utf16 * icu_buf_utf16_copy(struct icu_buf_utf16 * dest16, struct icu_buf_utf16 * src16) { - if(!dest16 || !src16 - || dest16 == src16) + if (!dest16 || !src16 || dest16 == src16) return 0; if (dest16->utf16_cap < src16->utf16_len) @@ -115,7 +115,6 @@ struct icu_buf_utf16 * icu_buf_utf16_copy(struct icu_buf_utf16 * dest16, return dest16; } - void icu_buf_utf16_destroy(struct icu_buf_utf16 * buf16) { if (buf16) @@ -123,8 +122,6 @@ void icu_buf_utf16_destroy(struct icu_buf_utf16 * buf16) xfree(buf16); } - - struct icu_buf_utf8 * icu_buf_utf8_create(size_t capacity) { struct icu_buf_utf8 * buf8 @@ -134,7 +131,8 @@ struct icu_buf_utf8 * icu_buf_utf8_create(size_t capacity) buf8->utf8_len = 0; buf8->utf8_cap = 0; - if (capacity > 0){ + if (capacity > 0) + { buf8->utf8 = (uint8_t *) xmalloc(sizeof(uint8_t) * capacity); buf8->utf8[0] = (uint8_t) 0; buf8->utf8_cap = capacity; @@ -142,10 +140,10 @@ struct icu_buf_utf8 * icu_buf_utf8_create(size_t capacity) return buf8; } - struct icu_buf_utf8 * icu_buf_utf8_clear(struct icu_buf_utf8 * buf8) { - if (buf8){ + if (buf8) + { if (buf8->utf8) buf8->utf8[0] = (uint8_t) 0; buf8->utf8_len = 0; @@ -153,7 +151,6 @@ struct icu_buf_utf8 * icu_buf_utf8_clear(struct icu_buf_utf8 * buf8) return buf8; } - struct icu_buf_utf8 * icu_buf_utf8_resize(struct icu_buf_utf8 * buf8, size_t capacity) { @@ -166,8 +163,7 @@ struct icu_buf_utf8 * icu_buf_utf8_resize(struct icu_buf_utf8 * buf8, else buf8->utf8 = (uint8_t *) xrealloc(buf8->utf8, sizeof(uint8_t) * capacity); - - icu_buf_utf8_clear(buf8); + buf8->utf8_cap = capacity; } else { @@ -180,24 +176,6 @@ struct icu_buf_utf8 * icu_buf_utf8_resize(struct icu_buf_utf8 * buf8, return buf8; } - -struct icu_buf_utf8 * icu_buf_utf8_copy(struct icu_buf_utf8 * dest8, - struct icu_buf_utf8 * src8) -{ - if(!dest8 || !src8 - || dest8 == src8) - return 0; - - - if (dest8->utf8_cap < src8->utf8_len) - icu_buf_utf8_resize(dest8, src8->utf8_len * 2); - - strncpy((char*) dest8->utf8, (char*) src8->utf8, src8->utf8_len); - - return dest8; -} - - const char *icu_buf_utf8_to_cstr(struct icu_buf_utf8 *src8) { if (!src8 || src8->utf8_len == 0) @@ -211,7 +189,6 @@ const char *icu_buf_utf8_to_cstr(struct icu_buf_utf8 *src8) return (const char *) src8->utf8; } - void icu_buf_utf8_destroy(struct icu_buf_utf8 * buf8) { if (buf8) @@ -219,39 +196,6 @@ void icu_buf_utf8_destroy(struct icu_buf_utf8 * buf8) xfree(buf8); } - - -UErrorCode icu_utf16_from_utf8(struct icu_buf_utf16 * dest16, - struct icu_buf_utf8 * src8, - UErrorCode * status) -{ - int32_t utf16_len = 0; - - u_strFromUTF8(dest16->utf16, dest16->utf16_cap, - &utf16_len, - (const char *) src8->utf8, src8->utf8_len, status); - - /* check for buffer overflow, resize and retry */ - if (*status == U_BUFFER_OVERFLOW_ERROR) - { - icu_buf_utf16_resize(dest16, utf16_len * 2); - *status = U_ZERO_ERROR; - u_strFromUTF8(dest16->utf16, dest16->utf16_cap, - &utf16_len, - (const char *) src8->utf8, src8->utf8_len, status); - } - - if (U_SUCCESS(*status) - && utf16_len <= dest16->utf16_cap) - dest16->utf16_len = utf16_len; - else - icu_buf_utf16_clear(dest16); - - return *status; -} - - - UErrorCode icu_utf16_from_utf8_cstr(struct icu_buf_utf16 * dest16, const char * src8cstr, UErrorCode * status) @@ -285,9 +229,6 @@ UErrorCode icu_utf16_from_utf8_cstr(struct icu_buf_utf16 * dest16, return *status; } - - - UErrorCode icu_utf16_to_utf8(struct icu_buf_utf8 * dest8, struct icu_buf_utf16 * src16, UErrorCode * status) @@ -306,7 +247,6 @@ UErrorCode icu_utf16_to_utf8(struct icu_buf_utf8 * dest8, u_strToUTF8((char *) dest8->utf8, dest8->utf8_cap, &utf8_len, src16->utf16, src16->utf16_len, status); - } if (U_SUCCESS(*status) @@ -326,7 +266,8 @@ struct icu_casemap * icu_casemap_create(char action, UErrorCode *status) = (struct icu_casemap *) xmalloc(sizeof(struct icu_casemap)); casemap->action = action; - switch(casemap->action) { + switch(casemap->action) + { case 'l': case 'L': case 'u': @@ -340,7 +281,6 @@ struct icu_casemap * icu_casemap_create(char action, UErrorCode *status) icu_casemap_destroy(casemap); return 0; } - return casemap; } @@ -349,7 +289,6 @@ void icu_casemap_destroy(struct icu_casemap * casemap) xfree(casemap); } - int icu_casemap_casemap(struct icu_casemap * casemap, struct icu_buf_utf16 * dest16, struct icu_buf_utf16 * src16, @@ -363,7 +302,6 @@ int icu_casemap_casemap(struct icu_casemap * casemap, casemap->action, status); } - int icu_utf16_casemap(struct icu_buf_utf16 * dest16, struct icu_buf_utf16 * src16, const char *locale, char action, @@ -371,16 +309,16 @@ int icu_utf16_casemap(struct icu_buf_utf16 * dest16, { int32_t dest16_len = 0; - - if (!src16->utf16_len){ /* guarding for empty source string */ + if (!src16->utf16_len) + { /* guarding for empty source string */ if (dest16->utf16) dest16->utf16[0] = (UChar) 0; dest16->utf16_len = 0; return U_ZERO_ERROR; } - - switch(action) { + switch(action) + { case 'l': case 'L': dest16_len = u_strToLower(dest16->utf16, dest16->utf16_cap, @@ -414,11 +352,11 @@ int icu_utf16_casemap(struct icu_buf_utf16 * dest16, /* check for buffer overflow, resize and retry */ if (*status == U_BUFFER_OVERFLOW_ERROR && dest16 != src16 /* do not resize if in-place conversion */ - ){ + ) + { icu_buf_utf16_resize(dest16, dest16_len * 2); *status = U_ZERO_ERROR; - switch(action) { case 'l': case 'L': @@ -454,7 +392,8 @@ int icu_utf16_casemap(struct icu_buf_utf16 * dest16, if (U_SUCCESS(*status) && dest16_len <= dest16->utf16_cap) dest16->utf16_len = dest16_len; - else { + else + { if (dest16->utf16) dest16->utf16[0] = (UChar) 0; dest16->utf16_len = 0; @@ -463,21 +402,19 @@ int icu_utf16_casemap(struct icu_buf_utf16 * dest16, return *status; } - - void icu_sortkey8_from_utf16(UCollator *coll, struct icu_buf_utf8 * dest8, struct icu_buf_utf16 * src16, UErrorCode * status) { - int32_t sortkey_len = 0; sortkey_len = ucol_getSortKey(coll, src16->utf16, src16->utf16_len, dest8->utf8, dest8->utf8_cap); /* check for buffer overflow, resize and retry */ - if (sortkey_len > dest8->utf8_cap) { + if (sortkey_len > dest8->utf8_cap) + { icu_buf_utf8_resize(dest8, sortkey_len * 2); sortkey_len = ucol_getSortKey(coll, src16->utf16, src16->utf16_len, dest8->utf8, dest8->utf8_cap); @@ -490,8 +427,6 @@ void icu_sortkey8_from_utf16(UCollator *coll, icu_buf_utf8_clear(dest8); } - - struct icu_tokenizer * icu_tokenizer_create(const char *locale, char action, UErrorCode *status) { @@ -506,8 +441,8 @@ struct icu_tokenizer * icu_tokenizer_create(const char *locale, char action, tokenizer->token_start = 0; tokenizer->token_end = 0; - - switch(tokenizer->action) { + switch(tokenizer->action) + { case 'l': case 'L': tokenizer->bi = ubrk_open(UBRK_LINE, locale, 0, 0, status); @@ -559,7 +494,6 @@ int icu_tokenizer_attach(struct icu_tokenizer * tokenizer, if (!tokenizer || !tokenizer->bi || !src16) return 0; - tokenizer->buf16 = src16; tokenizer->token_count = 0; tokenizer->token_id = 0; @@ -567,13 +501,12 @@ int icu_tokenizer_attach(struct icu_tokenizer * tokenizer, tokenizer->token_end = 0; ubrk_setText(tokenizer->bi, src16->utf16, src16->utf16_len, status); - - + if (U_FAILURE(*status)) return 0; return 1; -}; +} int32_t icu_tokenizer_next_token(struct icu_tokenizer * tokenizer, struct icu_buf_utf16 * tkn16, @@ -582,12 +515,10 @@ int32_t icu_tokenizer_next_token(struct icu_tokenizer * tokenizer, int32_t tkn_start = 0; int32_t tkn_end = 0; int32_t tkn_len = 0; - if (!tokenizer || !tokenizer->bi || !tokenizer->buf16 || !tokenizer->buf16->utf16_len) return 0; - /* never change tokenizer->buf16 and keep always invariant 0 <= tokenizer->token_start @@ -609,21 +540,21 @@ int32_t icu_tokenizer_next_token(struct icu_tokenizer * tokenizer, tkn_end = tokenizer->buf16->utf16_len; /* copy out if everything is well */ - if(U_FAILURE(*status)) + if (U_FAILURE(*status)) return 0; /* everything OK, now update internal state */ tkn_len = tkn_end - tkn_start; - if (0 < tkn_len){ + if (0 < tkn_len) + { tokenizer->token_count++; tokenizer->token_id++; } else { tokenizer->token_id = 0; } tokenizer->token_start = tkn_start; - tokenizer->token_end = tkn_end; - + tokenizer->token_end = tkn_end; /* copying into token buffer if it exists */ if (tkn16){ @@ -639,7 +570,6 @@ int32_t icu_tokenizer_next_token(struct icu_tokenizer * tokenizer, return tkn_len; } - int32_t icu_tokenizer_token_id(struct icu_tokenizer * tokenizer) { return tokenizer->token_id; @@ -665,77 +595,82 @@ int32_t icu_tokenizer_token_count(struct icu_tokenizer * tokenizer) return tokenizer->token_count; } +struct icu_transform * icu_transform_create(const char *id, char action, + const char *rules, + UErrorCode *status) +{ + struct icu_buf_utf16 *id16 = icu_buf_utf16_create(0); + struct icu_buf_utf16 *rules16 = icu_buf_utf16_create(0); + struct icu_transform * transform + = (struct icu_transform *) xmalloc(sizeof(struct icu_transform)); -struct icu_normalizer * icu_normalizer_create(const char *rules, char action, - UErrorCode *status) -{ + transform->action = action; + transform->trans = 0; - struct icu_normalizer * normalizer - = (struct icu_normalizer *) xmalloc(sizeof(struct icu_normalizer)); + if (id) + icu_utf16_from_utf8_cstr(id16, id, status); + if (rules) + icu_utf16_from_utf8_cstr(rules16, rules, status); - normalizer->action = action; - normalizer->trans = 0; - normalizer->rules16 = icu_buf_utf16_create(0); - icu_utf16_from_utf8_cstr(normalizer->rules16, rules, status); - - switch(normalizer->action) { + switch(transform->action) + { case 'f': case 'F': - normalizer->trans - = utrans_openU(normalizer->rules16->utf16, - normalizer->rules16->utf16_len, + transform->trans + = utrans_openU(id16->utf16, + id16->utf16_len, UTRANS_FORWARD, - 0, 0, - normalizer->parse_error, status); + rules16->utf16, + rules16->utf16_len, + &transform->parse_error, status); break; case 'r': case 'R': - normalizer->trans - = utrans_openU(normalizer->rules16->utf16, - normalizer->rules16->utf16_len, + transform->trans + = utrans_openU(id16->utf16, + id16->utf16_len, UTRANS_REVERSE , - 0, 0, - normalizer->parse_error, status); + rules16->utf16, + rules16->utf16_len, + &transform->parse_error, status); break; default: *status = U_UNSUPPORTED_ERROR; - return 0; break; } + icu_buf_utf16_destroy(rules16); + icu_buf_utf16_destroy(id16); if (U_SUCCESS(*status)) - return normalizer; + return transform; /* freeing if failed */ - icu_normalizer_destroy(normalizer); + icu_transform_destroy(transform); return 0; } - -void icu_normalizer_destroy(struct icu_normalizer * normalizer){ - if (normalizer) { - if (normalizer->rules16) - icu_buf_utf16_destroy(normalizer->rules16); - if (normalizer->trans) - utrans_close(normalizer->trans); - xfree(normalizer); +void icu_transform_destroy(struct icu_transform * transform) +{ + if (transform) + { + if (transform->trans) + utrans_close(transform->trans); + xfree(transform); } } - - -int icu_normalizer_normalize(struct icu_normalizer * normalizer, - struct icu_buf_utf16 * dest16, - struct icu_buf_utf16 * src16, - UErrorCode *status) +int icu_transform_trans(struct icu_transform * transform, + struct icu_buf_utf16 * dest16, + struct icu_buf_utf16 * src16, + UErrorCode *status) { - if (!normalizer || !normalizer->trans - || !src16 - || !dest16) + if (!transform || !transform->trans + || !src16 || !dest16) return 0; - if (!src16->utf16_len){ /* guarding for empty source string */ + if (!src16->utf16_len) + { /* guarding for empty source string */ icu_buf_utf16_clear(dest16); return 0; } @@ -743,8 +678,7 @@ int icu_normalizer_normalize(struct icu_normalizer * normalizer, if (!icu_buf_utf16_copy(dest16, src16)) return 0; - - utrans_transUChars (normalizer->trans, + utrans_transUChars (transform->trans, dest16->utf16, &(dest16->utf16_len), dest16->utf16_cap, 0, &(src16->utf16_len), status); @@ -755,9 +689,6 @@ int icu_normalizer_normalize(struct icu_normalizer * normalizer, return dest16->utf16_len; } - - - struct icu_chain_step * icu_chain_step_create(struct icu_chain * chain, enum icu_chain_step_type type, const uint8_t * rule, @@ -776,43 +707,52 @@ struct icu_chain_step * icu_chain_step_create(struct icu_chain * chain, step->buf16 = buf16; /* create auxilary objects */ - switch(step->type) { + switch(step->type) + { case ICU_chain_step_type_display: break; case ICU_chain_step_type_casemap: step->u.casemap = icu_casemap_create(rule[0], status); break; - case ICU_chain_step_type_normalize: - step->u.normalizer = icu_normalizer_create((char *) rule, 'f', status); + case ICU_chain_step_type_transform: + /* rule omitted. Only ID used */ + step->u.transform = icu_transform_create((const char *) rule, 'f', + 0, status); break; case ICU_chain_step_type_tokenize: step->u.tokenizer = icu_tokenizer_create((char *) chain->locale, (char) rule[0], status); break; + case ICU_chain_step_type_transliterate: + /* we pass a dummy ID to utrans_openU.. */ + step->u.transform = icu_transform_create("custom", 'f', + (const char *) rule, status); + break; default: break; } - return step; } -void icu_chain_step_destroy(struct icu_chain_step * step){ - +void icu_chain_step_destroy(struct icu_chain_step * step) +{ if (!step) return; icu_chain_step_destroy(step->previous); - switch(step->type) { + switch(step->type) + { case ICU_chain_step_type_display: break; case ICU_chain_step_type_casemap: icu_casemap_destroy(step->u.casemap); icu_buf_utf16_destroy(step->buf16); break; - case ICU_chain_step_type_normalize: - icu_normalizer_destroy(step->u.normalizer); + case ICU_chain_step_type_transform: + case ICU_chain_step_type_transliterate: + icu_transform_destroy(step->u.transform); icu_buf_utf16_destroy(step->buf16); break; case ICU_chain_step_type_tokenize: @@ -825,8 +765,6 @@ void icu_chain_step_destroy(struct icu_chain_step * step){ xfree(step); } - - struct icu_chain * icu_chain_create(const char *locale, int sort, UErrorCode * status) { @@ -859,7 +797,6 @@ struct icu_chain * icu_chain_create(const char *locale, int sort, return chain; } - void icu_chain_destroy(struct icu_chain * chain) { if (chain) @@ -879,8 +816,6 @@ void icu_chain_destroy(struct icu_chain * chain) } } - - struct icu_chain * icu_chain_xml_config(const xmlNode *xml_node, int sort, UErrorCode * status) @@ -921,7 +856,10 @@ struct icu_chain * icu_chain_xml_config(const xmlNode *xml_node, step = icu_chain_insert_step(chain, ICU_chain_step_type_casemap, (const uint8_t *) xml_rule, status); else if (!strcmp((const char *) node->name, "transform")) - step = icu_chain_insert_step(chain, ICU_chain_step_type_normalize, + step = icu_chain_insert_step(chain, ICU_chain_step_type_transform, + (const uint8_t *) xml_rule, status); + else if (!strcmp((const char *) node->name, "transliterate")) + step = icu_chain_insert_step(chain, ICU_chain_step_type_transliterate, (const uint8_t *) xml_rule, status); else if (!strcmp((const char *) node->name, "tokenize")) step = icu_chain_insert_step(chain, ICU_chain_step_type_tokenize, @@ -929,20 +867,35 @@ struct icu_chain * icu_chain_xml_config(const xmlNode *xml_node, else if (!strcmp((const char *) node->name, "display")) step = icu_chain_insert_step(chain, ICU_chain_step_type_display, (const uint8_t *) "", status); + else if (!strcmp((const char *) node->name, "normalize")) + { + yaz_log(YLOG_WARN, "Element %s is deprecated. " + "Use transform instead", node->name); + step = icu_chain_insert_step(chain, ICU_chain_step_type_transform, + (const uint8_t *) xml_rule, status); + } + else if (!strcmp((const char *) node->name, "index") + || !strcmp((const char *) node->name, "sortkey")) + { + yaz_log(YLOG_WARN, "Element %s is no longer needed. " + "Remove it from the configuration", node->name); + } + else + { + yaz_log(YLOG_WARN, "Unknown element %s", node->name); + icu_chain_destroy(chain); + return 0; + } xmlFree(xml_rule); - if (!step || U_FAILURE(*status)) + if (step && U_FAILURE(*status)) { icu_chain_destroy(chain); return 0; } - - } return chain; } - - struct icu_chain_step * icu_chain_insert_step(struct icu_chain * chain, enum icu_chain_step_type type, const uint8_t * rule, @@ -963,7 +916,6 @@ struct icu_chain_step * icu_chain_insert_step(struct icu_chain * chain, else return 0; - /* create utf16 destination buffers as needed, or */ switch(type) { @@ -973,16 +925,17 @@ struct icu_chain_step * icu_chain_insert_step(struct icu_chain * chain, case ICU_chain_step_type_casemap: buf16 = icu_buf_utf16_create(0); break; - case ICU_chain_step_type_normalize: + case ICU_chain_step_type_transform: + case ICU_chain_step_type_transliterate: buf16 = icu_buf_utf16_create(0); break; case ICU_chain_step_type_tokenize: buf16 = icu_buf_utf16_create(0); break; + break; default: break; } - /* create actual chain step with this buffer */ step = icu_chain_step_create(chain, type, rule, buf16, status); @@ -992,10 +945,9 @@ struct icu_chain_step * icu_chain_insert_step(struct icu_chain * chain, return step; } - -int icu_chain_step_next_token(struct icu_chain * chain, - struct icu_chain_step * step, - UErrorCode *status) +static int icu_chain_step_next_token(struct icu_chain * chain, + struct icu_chain_step * step, + UErrorCode *status) { struct icu_buf_utf16 * src16 = 0; int got_new_token = 0; @@ -1003,7 +955,7 @@ int icu_chain_step_next_token(struct icu_chain * chain, if (!chain || !chain->src16 || !step || !step->more_tokens) return 0; - /* assign utf16 src buffers as neeed, advance in previous steps + /* assign utf16 src buffers as needed, advance in previous steps tokens until non-zero token met, and setting stop condition */ if (step->previous) @@ -1048,9 +1000,10 @@ int icu_chain_step_next_token(struct icu_chain * chain, step->buf16, src16, status, chain->locale); break; - case ICU_chain_step_type_normalize: - icu_normalizer_normalize(step->u.normalizer, - step->buf16, src16, status); + case ICU_chain_step_type_transform: + case ICU_chain_step_type_transliterate: + icu_transform_trans(step->u.transform, + step->buf16, src16, status); break; case ICU_chain_step_type_tokenize: /* attach to new src16 token only first time during splitting */ @@ -1089,9 +1042,7 @@ int icu_chain_step_next_token(struct icu_chain * chain, return 1; } - -int icu_chain_assign_cstr(struct icu_chain * chain, - const char * src8cstr, +int icu_chain_assign_cstr(struct icu_chain * chain, const char * src8cstr, UErrorCode *status) { struct icu_chain_step * stp = 0; @@ -1124,10 +1075,7 @@ int icu_chain_assign_cstr(struct icu_chain * chain, return 1; } - - -int icu_chain_next_token(struct icu_chain * chain, - UErrorCode *status) +int icu_chain_next_token(struct icu_chain * chain, UErrorCode *status) { int got_token = 0; @@ -1155,7 +1103,7 @@ int icu_chain_next_token(struct icu_chain * chain, /* usual case, one or more icu chain steps existing */ else { - while(!got_token && chain->steps && chain->steps->more_tokens) + while (!got_token && chain->steps && chain->steps->more_tokens) got_token = icu_chain_step_next_token(chain, chain->steps, status); if (got_token) @@ -1168,7 +1116,6 @@ int icu_chain_next_token(struct icu_chain * chain, icu_sortkey8_from_utf16(chain->coll, chain->sort8, chain->steps->buf16, status); - return chain->token_count; } } @@ -1184,7 +1131,6 @@ int icu_chain_token_number(struct icu_chain * chain) return chain->token_count; } - const char * icu_chain_token_display(struct icu_chain * chain) { if (chain->display8) @@ -1222,7 +1168,9 @@ const UCollator * icu_chain_get_coll(struct icu_chain * chain) /* * Local variables: * c-basic-offset: 4 + * c-file-style: "Stroustrup" * indent-tabs-mode: nil * End: * vim: shiftwidth=4 tabstop=8 expandtab */ +