//
// returns 1 if the line is a N but not FF one
//
char check_N_not_FF(const struct dela_entry* d) {
unichar t1[2];
u_strcpy(t1,"N");
unichar t2[3];
u_strcpy(t2,"FF");
return (char)(dic_entry_contain_gram_code(d,t1) && !(dic_entry_contain_gram_code(d,t2)));
}
unichar_t *u_GFileNormalize(unichar_t *name) {
unichar_t *pt, *base, *ppt;
if ( (pt = uc_strstr(name,"://"))!=NULL ) {
base = u_strchr(pt+3,'/');
if ( base==NULL )
return( name );
++base;
} else if ( *name=='/' )
base = name+1;
else
base = name;
for ( pt=base; *pt!='\0'; ) {
if ( *pt=='/' )
u_strcpy(pt,pt+1);
else if ( uc_strncmp(pt,"./",2)==0 )
u_strcpy(pt,pt+2);
else if ( uc_strncmp(pt,"../",2)==0 ) {
for ( ppt=pt-2; ppt>=base && *ppt!='/'; --ppt );
++ppt;
if ( ppt>=base ) {
u_strcpy(ppt,pt+3);
pt = ppt;
} else
pt += 3;
} else {
while ( *pt!='/' && *pt!='\0' ) ++pt;
if ( *pt == '/' ) ++pt;
}
}
return( name );
}
// Routine to load date qualifier strings from resources. Do not call before AfApp has m_hinst.
void LoadDateQualifiers()
{
if (g_fDoneDateQual)
return;
int i;
for (i = 0; i < 5; i++)
{
StrUni stu(g_rgridDateQual1[i]);
Assert(stu.Length() < knPrecLen);
u_strcpy(g_rgchwPrecFull[i], stu.Chars());
StrAnsi sta(g_rgridDateQual1[i]);
Assert(sta.Length() < knPrecLen);
strcpy_s(g_rgchPrecFull[i], sta.Length(), sta.Chars());
}
for (i = 0; i < 2; i++)
{
StrUni stu(g_rgridDateQual2[i]);
Assert(stu.Length() < knAdBcLen);
u_strcpy(g_rgchwBC_ADFull[i], stu.Chars());
StrAnsi sta(g_rgridDateQual2[i]);
Assert(stu.Length() < knAdBcLen);
strcpy_s(g_rgchBC_ADFull[i], sta.Length(), sta.Chars());
}
for (i = 0; i < 3; i++)
{
StrUni stu(g_rgridDateBlank[i]);
Assert(stu.Length() < knBlankLen);
u_strcpy(g_rgchwBlankFull[i], stu.Chars());
StrAnsi sta(g_rgridDateBlank[i]);
Assert(stu.Length() < knBlankLen);
strcpy_s(g_rgchBlankFull[i], sta.Length(), sta.Chars());
}
g_fDoneDateQual = true;
}
unichar_t* Wordlist_advanceSelectedCharsBy( SplineFont* sf, EncMap *map, unichar_t* txtu, int offset )
{
unichar_t original_data[ PATH_MAX ];
static unichar_t ret[ PATH_MAX ];
int i = 0;
u_strcpy( original_data, txtu );
TRACE("Wordlist_advanceSelectedCharsBy(1) %s\n", u_to_c( txtu ));
WordlistTrimTrailingSingleSlash( txtu );
WordListLine wll = WordlistEscapedInputStringToParsedData( sf, txtu );
int selectedCount = WordListLine_countSelected( wll );
if( !selectedCount )
wll->isSelected = 1;
memset( ret, 0, sizeof(unichar_t) * PATH_MAX );
for( i = 0; wll->sc; wll++, i++ )
{
SplineChar* sc = wll->sc;
int element_selected = wll->isSelected;
if( element_selected )
{
int pos = map->backmap[ sc->orig_pos ];
pos += offset;
int gid = pos < 0 || pos >= map->enccount ? -2 : map->map[pos];
if( gid == -2 )
{
// we can't find a glyph at the desired position.
// so instead of dropping it we just do not perform the operation
// on this char.
pos -= offset;
gid = pos < 0 || pos >= map->enccount ? -2 : map->map[pos];
if( gid == -2 )
{
// we can't go back manually!
u_strcpy( ret, original_data );
return ret;
}
}
if( gid==-1 || !sf->glyphs[gid] )
sc = SFMakeChar( sf, map, pos );
else
sc = sf->glyphs[gid];
}
if( element_selected )
uc_strcat( ret, "[" );
/* uc_strcat( ret, "/" ); */
/* uc_strcat( ret, scarray[i]->name ); */
uc_strcat( ret, Wordlist_getSCName( sc ));
if( element_selected )
uc_strcat( ret, "]" );
}
return ret;
}
/**
* Returns 1 if the given dictionary entry is a "V" one that does
* not have the inflectional code "Y".
*/
char check_V_but_not_Y(struct dela_entry* d) {
unichar t1[2];
u_strcpy(t1,"V");
unichar t2[2];
u_strcpy(t2,"Y");
return dic_entry_contain_gram_code(d,t1) && (!dic_entry_contain_inflectional_code(d,t2));
}
/**
* Returns 1 if the given dictionary entry is a "V:W" one.
*/
char check_VW(const struct dela_entry* d) {
unichar t1[2];
u_strcpy(t1,"V");
unichar t2[2];
u_strcpy(t2,"W");
return dic_entry_contain_gram_code(d,t1) && dic_entry_contain_inflectional_code(d,t2);
}
// names for affixes and rules can be choosen individually for each language
// definition in "<language>Compounds.cpp"
// struct _tags TAG and typedef tags declared in .h
// unicode version of names:
struct utags init_utags (tags T)
{
struct utags UTAG;
u_strcpy(UTAG.PREFIX, T.PREFIX);
u_strcpy(UTAG.SUFFIX, T.SUFFIX);
u_strcpy(UTAG.RULE, T.RULE);
return UTAG;
}
struct composition_rule* copy_composition_rule (struct composition_rule* a,
struct composition_rule* b)
{
for (int i = 0; i < MAX_NUMBER_OF_COMPOSITION_RULES; i++) {
u_strcpy(a->before[i].string, b->before[i].string);
a->before[i].YesNo = b->before[i].YesNo;
a->before[i].type = b->before[i].type;
if (a->before[i].string[0] == '\0')
break;
}
for (int i = 0; i < MAX_NUMBER_OF_COMPOSITION_RULES; i++) {
u_strcpy(a->after[i].string, b->after[i].string);
a->after[i].YesNo = b->after[i].YesNo;
a->after[i].type = b->after[i].type;
if (a->after[i].string[0] == '\0')
break;
}
u_strcpy(a->then.add, b->then.add);
u_strcpy(a->then.del, b->then.del);
u_strcpy(a->then.repl, b->then.repl);
u_strcpy(a->then.substr_act, b->then.substr_act);
u_strcpy(a->then.substr_next, b->then.substr_next);
u_strcpy(a->then.undo_substr_act, b->then.undo_substr_act);
u_strcpy(a->then.undo_substr_next, b->then.undo_substr_next);
return a;
}
/**
* This function moves outputs from final nodes to transitions leading to final nodes.
*/
static void subsequential_to_normal_transducer(struct dictionary_node* root,
struct dictionary_node* node,
struct string_hash* inf_codes,
int pos,unichar* z,
Ustring* normalizedOutput) {
struct dictionary_node_transition* tmp=node->trans;
int prefix_set=0;
Ustring* prefix=new_Ustring();
while (tmp!=NULL) {
z[pos]=tmp->letter;
z[pos+1]='\0';
subsequential_to_normal_transducer(root,tmp->node,inf_codes,pos+1,z,normalizedOutput);
/* First, if the destination state is final, we place its output on the output
* of the current transition */
if (tmp->node->single_INF_code_list!=NULL) {
//error("<%S>: output=<%S>\n",z,normalizedOutput->str);
tmp->output=u_strdup(inf_codes->value[tmp->node->INF_code]);
}
if (normalizedOutput->len!=0) {
/* Then, we add the normalized output obtained recursively, if any */
//error("<%S>: moving normalized output <%S>\n",z,normalizedOutput->str);
if (tmp->output==NULL) {
tmp->output=u_strdup(normalizedOutput->str);
} else {
tmp->output=(unichar*)realloc(tmp->output,sizeof(unichar)*(1+normalizedOutput->len+u_strlen(tmp->output)));
}
}
if (!prefix_set) {
prefix_set=1;
u_strcpy(prefix,tmp->output);
} else {
get_longest_common_prefix(prefix,tmp->output);
}
tmp=tmp->next;
}
if (node==root || node->single_INF_code_list!=NULL) {
/* If we are in the initial state or a final one, we let the transitions as they are, since
* their outputs can not move more to the left */
z[pos]='\0';
free_Ustring(prefix);
empty(normalizedOutput);
return;
}
tmp=node->trans;
while (tmp!=NULL) {
//error("prefix removal: <%S> => ",tmp->output);
remove_prefix(prefix->len,tmp->output);
//error("<%S>\n",tmp->output);
tmp=tmp->next;
}
z[pos]='\0';
u_strcpy(normalizedOutput,prefix);
free_Ustring(prefix);
}
/**
* Allocates, initializes and returns a new corpus_entry structure.
*/
struct corpus_entry* new_corpus_entry(const unichar* line){
struct corpus_entry* entry = (corpus_entry*)malloc(sizeof(corpus_entry));
if(entry == NULL){
fatal_alloc_error("compute_corpus_entry");
}
/* we fill corpus entry with information extracted from the corpus line*/
int pos = u_strrchr(line,'/');
if(pos == -1){
fatal_error("Wrong format for line %S\n",line);
}
entry->word = (unichar*)malloc(sizeof(unichar)*(pos+1));
if(entry->word == NULL){
fatal_alloc_error("compute_corpus_entry");
}
unichar* tmp = u_strcpy_sized(entry->word,pos+1,line);
u_strcat(tmp,"\0");
int code_pos = u_strrchr(line,':');
/* there are no morphological codes associated to this entry */
if(code_pos == -1){
entry->pos_code = (unichar*)malloc(sizeof(unichar)*(u_strlen(line)-pos));
if(entry->pos_code == NULL){
fatal_alloc_error("new_corpus_entry");
}
u_strcpy(entry->pos_code,&line[pos+1]);
entry->overall_codes = u_strdup(entry->pos_code);
}
else{
entry->pos_code = (unichar*)malloc(sizeof(unichar)*(code_pos-pos));
if(entry->pos_code == NULL){
fatal_alloc_error("new_corpus_entry");
}
entry->overall_codes = (unichar*)malloc(sizeof(unichar)*(u_strlen(line)-pos));
if(entry->overall_codes == NULL){
fatal_alloc_error("new_corpus_entry");
}
unichar* tmp2 = u_strcpy_sized(entry->pos_code,code_pos-pos,&line[pos+1]);
u_strcat(tmp2,"\0");
u_strcpy(entry->overall_codes,&line[pos+1]);
}
/* if the token is not annotated in the corpus, we put "UNK" */
if(u_strlen(entry->pos_code) == 0){
free(entry->pos_code);
free(entry->overall_codes);
entry->pos_code = u_strdup("UNK");
entry->overall_codes = u_strdup("UNK");
}
return entry;
}
U_CAPI double U_EXPORT2
unum_parseDoubleCurrency(const UNumberFormat* fmt,
const UChar* text,
int32_t textLength,
int32_t* parsePos, /* 0 = start */
UChar* currency,
UErrorCode* status) {
double doubleVal = 0.0;
currency[0] = 0;
if (U_FAILURE(*status)) {
return doubleVal;
}
const UnicodeString src((UBool)(textLength == -1), text, textLength);
ParsePosition pp;
if (parsePos != NULL) {
pp.setIndex(*parsePos);
}
*status = U_PARSE_ERROR; // assume failure, reset if succeed
LocalPointer<CurrencyAmount> currAmt(((const NumberFormat*)fmt)->parseCurrency(src, pp));
if (pp.getErrorIndex() != -1) {
if (parsePos != NULL) {
*parsePos = pp.getErrorIndex();
}
} else {
if (parsePos != NULL) {
*parsePos = pp.getIndex();
}
if (pp.getIndex() > 0) {
*status = U_ZERO_ERROR;
u_strcpy(currency, currAmt->getISOCurrency());
doubleVal = currAmt->getNumber().getDouble(*status);
}
}
return doubleVal;
}
/**
* Loads the initial keyword list from a tok_by_freq.txt file,
* and turns all those tokens in a list whose primary key is the
* lower case token:
* The/20 THE/2 the/50 => the->(The/20 THE/2 the/50)
*/
struct string_hash_ptr* load_tokens_by_freq(char* name,VersatileEncodingConfig* vec) {
U_FILE* f=u_fopen(vec,name,U_READ);
if (f==NULL) return NULL;
Ustring* line=new_Ustring(128);
Ustring* lower=new_Ustring(128);
struct string_hash_ptr* res=new_string_hash_ptr(1024);
int val,pos;
/* We skip the first line of the file, containing the number
* of tokens
*/
if (EOF==readline(line,f)) {
fatal_error("Invalid empty file %s\n",name);
}
while (EOF!=readline(line,f)) {
if (1!=u_sscanf(line->str,"%d%n",&val,&pos)) {
fatal_error("Invalid line in file %s:\n%S\n",name,line->str);
}
u_strcpy(lower,line->str+pos);
u_tolower(lower->str);
int index=get_value_index(lower->str,res,INSERT_IF_NEEDED,NULL);
if (index==-1) {
fatal_error("Internal error in load_tokens_by_freq\n");
}
KeyWord* value=(KeyWord*)res->value[index];
res->value[index]=new_KeyWord(val,line->str+pos,value);
}
free_Ustring(line);
free_Ustring(lower);
u_fclose(f);
return res;
}
/**
* Loads a compound word file, adding each word to the keywords.
*/
void load_compound_words(char* name,VersatileEncodingConfig* vec,
struct string_hash_ptr* keywords) {
U_FILE* f=u_fopen(vec,name,U_READ);
if (f==NULL) return;
Ustring* line=new_Ustring(256);
Ustring* lower=new_Ustring(256);
while (EOF!=readline(line,f)) {
if (line->str[0]=='{') {
/* We skip tags */
continue;
}
u_strcpy(lower,line->str);
u_tolower(lower->str);
int index=get_value_index(lower->str,keywords,INSERT_IF_NEEDED,NULL);
if (index==-1) {
fatal_error("Internal error in load_tokens_by_freq\n");
}
KeyWord* value=(KeyWord*)keywords->value[index];
add_keyword(&value,line->str,1);
keywords->value[index]=value;
}
free_Ustring(line);
free_Ustring(lower);
u_fclose(f);
}
const UChar *ZNStringPool::get(const UChar *s, UErrorCode &status) {
const UChar *pooledString;
if (U_FAILURE(status)) {
return &EmptyString;
}
pooledString = static_cast<UChar *>(uhash_get(fHash, s));
if (pooledString != NULL) {
return pooledString;
}
int32_t length = u_strlen(s);
int32_t remainingLength = POOL_CHUNK_SIZE - fChunks->fLimit;
if (remainingLength <= length) {
U_ASSERT(length < POOL_CHUNK_SIZE);
if (length >= POOL_CHUNK_SIZE) {
status = U_INTERNAL_PROGRAM_ERROR;
return &EmptyString;
}
ZNStringPoolChunk *oldChunk = fChunks;
fChunks = new ZNStringPoolChunk;
if (fChunks == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return &EmptyString;
}
fChunks->fNext = oldChunk;
}
UChar *destString = &fChunks->fStrings[fChunks->fLimit];
u_strcpy(destString, s);
fChunks->fLimit += (length + 1);
uhash_put(fHash, destString, destString, &status);
return destString;
}
void save_pattern (pattern* patterns, bool YesNo, unichar type, const unichar* patt)
{
patterns->YesNo = YesNo;
patterns->type = type;
patterns->string[0] = '\0';
u_strcpy(patterns->string, patt);
}
UINT64 *Uint64Comp::u_strdup(UINT64 *s) {
int length = u_strlen(s) + 1;
UINT64 *result = (UINT64*)malloc(length*sizeof(UINT64));
if (result == (UINT64*)0){return (UINT64*)0;}
u_strcpy(result, s);
return result;
}
static void demo_C_Unicode_strings() {
printf("\n* demo_C_Unicode_strings() --------- ***\n\n");
static const UChar text[]={ 0x41, 0x42, 0x43, 0 }; /* "ABC" */
static const UChar appendText[]={ 0x61, 0x62, 0x63, 0 }; /* "abc" */
static const UChar cmpText[]={ 0x61, 0x53, 0x73, 0x43, 0 }; /* "aSsC" */
UChar buffer[32];
int32_t compare;
int32_t length=u_strlen(text); /* length=3 */
/* simple ANSI C-style functions */
buffer[0]=0; /* empty, NUL-terminated string */
u_strncat(buffer, text, 1); /* append just n=1 character ('A') */
u_strcat(buffer, appendText); /* buffer=="Aabc" */
length=u_strlen(buffer); /* length=4 */
printUString("should be \"Aabc\": ", buffer, -1);
/* bitwise comparing buffer with text */
compare=u_strcmp(buffer, text);
if(compare<=0) {
printf("String comparison error, expected \"Aabc\" > \"ABC\"\n");
}
/* Build "A<sharp s>C" in the buffer... */
u_strcpy(buffer, text);
buffer[1]=0xdf; /* sharp s, case-compares equal to "ss" */
printUString("should be \"A<sharp s>C\": ", buffer, -1);
/* Compare two strings case-insensitively using full case folding */
compare=u_strcasecmp(buffer, cmpText, U_FOLD_CASE_DEFAULT);
if(compare!=0) {
printf("String case insensitive comparison error, expected \"AbC\" to be equal to \"ABC\"\n");
}
}
UChar *
make_alphabet(const UChar *source)
{
UChar *dest;
int sourcelen = u_strlen(source);
int x, y;
dest = safe_calloc(sourcelen + 1, sizeof(UChar));
u_strcpy(dest, source);
/* Very simple ripple sort as these are very short strings */
/* No advantage in using qsort() or similar */
for (x = 0; x < sourcelen - 1; x++) {
for (y = x + 1; y < sourcelen ; y++) {
if (dest[x] > dest[y]) {
UChar temp;
temp = dest[x];
dest[x] = dest[y];
dest[y] = temp;
}
}
}
x = y = 0;
while (dest[x]) {
if (dest[x] != dest[y])
dest[++y] = dest[x];
x++;
}
dest[++y] = dest[x];
return dest;
}
/**
* This function loads concordance lines from 'f1' and/or 'f2' and prints them to
* 'output' in the given color.
*/
void print_diff_matches(U_FILE* output,U_FILE* f1,U_FILE* f2,const char* color,
unichar* match1,unichar* match2) {
unichar left1[MAX_CONTEXT_IN_UNITS];
unichar middle1[MAX_CONTEXT_IN_UNITS];
unichar right1[MAX_CONTEXT_IN_UNITS];
unichar indices1[MAX_CONTEXT_IN_UNITS];
unichar left2[MAX_CONTEXT_IN_UNITS];
unichar middle2[MAX_CONTEXT_IN_UNITS];
unichar right2[MAX_CONTEXT_IN_UNITS];
unichar indices2[MAX_CONTEXT_IN_UNITS];
if (f1!=NULL) {
read_concordance_line(f1,left1,middle1,right1,indices1,match1==NULL?0:u_strlen(match1));
}
if (f2!=NULL) {
read_concordance_line(f2,left2,middle2,right2,indices2,match2==NULL?0:u_strlen(match2));
}
if (match1!=NULL) u_strcpy(middle1,match1);
if (match2!=NULL) u_strcpy(middle2,match2);
if (!strcmp(color,RED)) {
/* If we have one match included in the another, we want to align
* them. We do that by adjusting their left contexts */
int pos1,pos2;
u_sscanf(indices1,"%d",&pos1);
u_sscanf(indices2,"%d",&pos2);
if (pos1<pos2) {
adjust(left1,left2,middle1,pos2-pos1);
} else if (pos1>pos2) {
adjust(left2,left1,middle2,pos1-pos2);
} /* Nothing to adjust if pos1==pos2 */
}
/* We print the line from the first file, if needed */
u_fprintf(output,"<tr><td nowrap bgcolor=\"#FFE4C4\"><font color=\"%s\">",color);
if (f1!=NULL) {
u_fprintf(output,"%HS<a href=\"%S\" style=\"color:%s\">%HS</a>%HS",left1,indices1,color,middle1,right1);
} else {
u_fprintf(output," ");
}
u_fprintf(output,"</font></td></tr>\n");
u_fprintf(output,"<tr><td nowrap bgcolor=\"#90EE90\"><font color=\"%s\">",color);
/* We print the line from the second file, if needed */
if (f2!=NULL) {
u_fprintf(output,"%HS<a href=\"%S\" style=\"color:%s\">%HS</a>%HS",left2,indices2,color,middle2,right2);
} else {
u_fprintf(output," ");
}
u_fprintf(output,"</font></td></tr>\n");
}
/**
* This function parses a DELAF line and stores in the appropriate parameters
* the inflected form, the lemma and the codes. If there is no lemma, it takes
* the value of the inflected form. All these strings are unprotected:
*
* "3\,14,.PI" => inflected="3,14" lemma="3,14" codes="PI"
*/
void tokenize_DELA_line_into_3_parts(const unichar* line,unichar* inflected,unichar* lemma,unichar* codes) {
int i,j;
if (line==NULL) return;
/* We read the inflected form */
i=0;
j=0;
while (line[i]!='\0' && line[i]!=',') {
if (line[i]=='\\') {
/* We unprotect chars */
i++;
if (line[i]=='\0') {
error("***Dictionary error: incorrect line\n%S\n",line);
return;
}
}
inflected[j++]=line[i++];
}
inflected[j]='\0';
if (line[i]=='\0') {
error("***Dictionary error: incorrect line\n%S\n",line);
return;
}
/* We read the lemma */
i++;
j=0;
while (line[i]!='\0' && line[i]!='.') {
if (line[i]=='\\') {
i++;
if (line[i]=='\0') {
error("***Dictionary error: incorrect line\n%S\n",line);
return;
}
}
lemma[j++]=line[i++];
}
lemma[j]='\0';
if (j==0) {
/* If the lemma is not specified, we copy the inflected form */
u_strcpy(lemma,inflected);
}
if (line[i]=='\0') {
error("***Dictionary error: incorrect line\n%S\n",line);
return;
}
/* We read the remaining part of the line */
i++;
j=0;
while (line[i]!='\0') {
if (line[i]=='\\') {
i++;
if (line[i]=='\0') {
error("***Dictionary error: incorrect line\n%S\n",line);
return;
}
}
codes[j++]=line[i++];
}
codes[j]='\0';
}
bool Wordlist_selectionsEqual( unichar_t* s1, unichar_t* s2 )
{
static unichar_t s1stripped[ PATH_MAX ];
static unichar_t s2stripped[ PATH_MAX ];
int s1HasSelection = 0;
int s2HasSelection = 0;
u_strcpy( s1stripped, Wordlist_selectionStringOnly( s1, &s1HasSelection ));
u_strcpy( s2stripped, Wordlist_selectionStringOnly( s2, &s2HasSelection ));
if( s1HasSelection && !s2HasSelection )
return false;
if( !s1HasSelection && s2HasSelection )
return false;
return !u_strcmp( s1stripped, s2stripped );
}
/**
* Returns 1 if the line is a valid right "A" component.
*/
char check_A_right_component(unichar* s) {
/* We produce an artifical dictionary entry with the given INF code,
* and then, we tokenize it in order to get grammatical and inflectional
* codes in a structured way. */
unichar temp[2000];
u_strcpy(temp,"x,");
u_strcat(temp,s);
struct dela_entry* d=tokenize_DELAF_line(temp,0);
unichar t1[2];
u_strcpy(t1,"A");
unichar t2[4];
u_strcpy(t2,"sie");
char res=dic_entry_contain_gram_code(d,t1) && !dic_entry_contain_inflectional_code(d,t2);
/* We free the artifical dictionary entry */
free_dela_entry(d);
return res;
}
void LEXIC_trans_write(Elag_fst_file_out * fstf, int to) {
unichar label[8];
int idx;
u_strcpy(label, "<MOT>");
idx=get_value_index(label,fstf->labels);
u_fprintf(fstf->f, "%d %d ", idx, to);
u_strcpy(label, "<!MOT>");
idx=get_value_index(label,fstf->labels);
u_fprintf(fstf->f, "%d %d ", idx, to);
}
CurrencyUnit& CurrencyUnit::operator=(const CurrencyUnit& other) {
if (this == &other) {
return *this;
}
MeasureUnit::operator=(other);
u_strcpy(isoCode, other.isoCode);
return *this;
}
/**
* Copies src into fst, and then appends the nth first chars of middle.
*/
static void adjust(unichar* src,unichar* dst,unichar* middle,int n) {
u_strcpy(dst,src);
int pos=u_strlen(dst);
for (int i=0;i<n;i++) {
dst[pos++]=middle[i];
}
dst[pos]='\0';
}
unichar_t *u_GFileGetAbsoluteName(unichar_t *name, unichar_t *result, int rsiz) {
/* result may be the same as name */
unichar_t buffer[1000];
if ( ! u_GFileIsAbsolute(name) ) {
unichar_t *pt, *spt, *rpt, *bpt;
if ( dirname_[0]=='\0' ) {
getcwd(dirname_,sizeof(dirname_));
}
uc_strcpy(buffer,dirname_);
if ( buffer[u_strlen(buffer)-1]!='/' )
uc_strcat(buffer,"/");
u_strcat(buffer,name);
_u_backslash_to_slash(buffer);
/* Normalize out any .. */
spt = rpt = buffer;
while ( *spt!='\0' ) {
if ( *spt=='/' ) ++spt;
for ( pt = spt; *pt!='\0' && *pt!='/'; ++pt );
if ( pt==spt ) /* Found // in a path spec, reduce to / (we've*/
u_strcpy(spt,pt); /* skipped past the :// of the machine name) */
else if ( pt==spt+1 && spt[0]=='.' && *pt=='/' ) /* Noop */
u_strcpy(spt,spt+2);
else if ( pt==spt+2 && spt[0]=='.' && spt[1]=='.' ) {
for ( bpt=spt-2 ; bpt>rpt && *bpt!='/'; --bpt );
if ( bpt>=rpt && *bpt=='/' ) {
u_strcpy(bpt,pt);
spt = bpt;
} else {
rpt = pt;
spt = pt;
}
} else
spt = pt;
}
name = buffer;
}
if (result!=name) {
u_strncpy(result,name,rsiz);
result[rsiz-1]='\0';
_u_backslash_to_slash(result);
}
return(result);
}
//
// returns 1 if the INF code refers to a valid right component, 0 else
//
char check_valid_right_component_for_one_INF_code_german(const unichar* s) {
unichar temp[2000];
u_strcpy(temp,"x,");
u_strcat(temp,s);
struct dela_entry* d=tokenize_DELAF_line(temp,0);
char res=check_N_not_FF(d);
free_dela_entry(d);
return res;
}
unichar_t *u_GFileAppendFile(unichar_t *dir,unichar_t *name,int isdir) {
unichar_t *ret, *pt;
ret = (unichar_t *) malloc((u_strlen(dir)+u_strlen(name)+3)*sizeof(unichar_t));
u_strcpy(ret,dir);
pt = ret+u_strlen(ret);
if ( pt>ret && pt[-1]!='/' )
*pt++ = '/';
u_strcpy(pt,name);
if ( isdir ) {
pt += u_strlen(pt);
if ( pt>ret && pt[-1]!='/' ) {
*pt++ = '/';
*pt = '\0';
}
}
return(ret);
}
TZEnumeration(const char* country) : map(NULL), len(0), pos(0) {
if (!getOlsonMeta()) {
return;
}
UErrorCode ec = U_ZERO_ERROR;
UResourceBundle *res = ures_openDirect(0, kZONEINFO, &ec);
ures_getByKey(res, kREGIONS, res, &ec);
if (U_SUCCESS(ec) && ures_getType(res) == URES_ARRAY) {
UChar uCountry[] = {0, 0, 0, 0};
if (country) {
u_charsToUChars(country, uCountry, 2);
} else {
u_strcpy(uCountry, WORLD);
}
// count matches
int32_t count = 0;
int32_t i;
const UChar *region;
for (i = 0; i < ures_getSize(res); i++) {
region = ures_getStringByIndex(res, i, NULL, &ec);
if (U_FAILURE(ec)) {
break;
}
if (u_strcmp(uCountry, region) == 0) {
count++;
}
}
if (count > 0) {
map = (int32_t*)uprv_malloc(sizeof(int32_t) * count);
if (map != NULL) {
int32_t idx = 0;
for (i = 0; i < ures_getSize(res); i++) {
region = ures_getStringByIndex(res, i, NULL, &ec);
if (U_FAILURE(ec)) {
break;
}
if (u_strcmp(uCountry, region) == 0) {
map[idx++] = i;
}
}
if (U_SUCCESS(ec)) {
len = count;
} else {
uprv_free(map);
map = NULL;
}
} else {
U_DEBUG_TZ_MSG(("Failed to load tz for region %s: %s\n", country, u_errorName(ec)));
}
}
}
ures_close(res);
}
int check_is_valid_for_one_INF_code(const unichar* t, const unichar* s)
{
unichar temp[MAX_DICT_LINE_LENGTH];
u_strcpy(temp,"x,");
u_strcat(temp,s);
struct dela_entry* d = tokenize_DELAF_line(temp,0);
int res = check_is_valid(t, d);
free_dela_entry(d);
return res;
}
