/rusxmms/librcc

To get this branch, use:
bzr branch http://suren.me/webbzr/rusxmms/librcc

« back to all changes in this revision

Viewing changes to src/lngconfig.c

  • Committer: Suren A. Chilingaryan
  • Date: 2005-06-16 23:14:30 UTC
  • Revision ID: Arch-1:ds@dside.dyndns.org--darksoft-2004%librcc--main--0.1--base-0
Initial Import

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lngconfig.c
 
1
#include <stdio.h>
 
2
#include <string.h>
 
3
 
 
4
#include <librcd.h>
 
5
#include "librcc.h"
 
6
#include "config.h"
 
7
 
 
8
const char *rccConfigGetEngineName(rcc_language_config config, rcc_engine_id engine_id) {
 
9
    rcc_engine_ptr *engines;
 
10
    
 
11
    if ((!config)||(!config->language)||(engine_id<0)) return NULL;
 
12
 
 
13
    engines = config->language->engines;
 
14
    
 
15
    for (i=0;engines[i];i++);
 
16
    if (engine_id>=i) return NULL;
 
17
    
 
18
    return engines[engine_id]->title;
 
19
}
 
20
 
 
21
const char *rccConfigGetCharsetName(rcc_language_config config, rcc_charset_id charset_id) {
 
22
    rcc_charset_ptr *charsets;
 
23
    
 
24
    if ((!config)||(!config->language)||(charset_id<0)) return NULL;
 
25
 
 
26
    charsets = config->language->charsets;
 
27
    
 
28
    for (i=0;charsets[i];i++);
 
29
    if (charset_id>=i) return NULL;
 
30
    
 
31
    return charsets[charset_id];
 
32
}
 
33
 
 
34
const char *rccConfigGetAutoCharsetName(rcc_language_config config, rcc_charset_id charset_id) {
 
35
    rcc_charset_ptr *charsets;
 
36
    rcc_engine_ptr *engines;
 
37
    
 
38
    if ((!config)||(!config->language)||(engine_id<0)) return NULL;
 
39
 
 
40
    engines = config->language->engines;
 
41
    charsets = engines[config->engine]->charsets;
 
42
 
 
43
    for (i=0;charsets[i];i++);
 
44
    if (charset_id>=i) return NULL;
 
45
    
 
46
    return charsets[charset_id];
 
47
}
 
48
 
 
49
 
 
50
rcc_engine_id rccConfigGetEngineByName(rcc_language_config *config, const char *name) {
 
51
    unsigned int i;
 
52
    rcc_engine *engines;
 
53
 
 
54
    if ((!config)||(!config->language)||(!name)) return -1;
 
55
    
 
56
    engines = config->language->engines;
 
57
    for (i=0;engines[i];i++)
 
58
        if (!strcmp(engines[i]->title,name)) return i;
 
59
    
 
60
    return -1;
 
61
}
 
62
 
 
63
rcc_charset_id rccConfigGetCharsetByName(rcc_language_config *config, const char *name) {
 
64
    unsigned int i;
 
65
    rcc_charset *charsets;
 
66
 
 
67
    if ((!config)||(!config->language)||(!name)) return -1;
 
68
    
 
69
    charsets = config->language->charsets;
 
70
    for (i=0;charsets[i];i++)
 
71
        if (!strcmp(charsets[i],name)) return i;
 
72
    
 
73
    return 0;
 
74
}
 
75
 
 
76
rcc_charset_id rccConfigGetAutoCharsetByName(rcc_language_config *config, const char *name) {
 
77
    unsigned int i;
 
78
    rcc_charset *charsets;
 
79
    rcc_engine_ptr *engines;
 
80
 
 
81
    if ((!config)||(!config->language)||(!name)) return -1;
 
82
 
 
83
    engines = config->language->engines;
 
84
    charsets = engines[config->engine]->charsets;
 
85
    
 
86
    for (i=0;charsets[i];i++)
 
87
        if (!strcmp(charsets[i],name)) return i;
 
88
    
 
89
    return -1;
 
90
}
 
91
 
 
92
int rccConfigInit(rcc_language_config *config, rcc_context *ctx) {
 
93
    rcc_charset_id *charsets;
 
94
 
 
95
    if ((!ctx)||(!config)) return -1;
 
96
    
 
97
    charsets = (rcc_charset_id*)malloc((ctx->max_classes)*sizeof(rcc_charset_id));
 
98
    if (!charsets) return -1;
 
99
    
 
100
    for (i=0;i<ctx->max_classes;i++)
 
101
        charsets[i] = 0;
 
102
 
 
103
    config->ctx = ctx;
 
104
    config->language = NULL;
 
105
    config->charset = charsets;
 
106
    config->engine = -1;
 
107
    for (i=0;i<RCC_MAX_OPTIONS;i++)
 
108
        config->options[i] = 0;    
 
109
 
 
110
    return 0;
 
111
}
 
112
 
 
113
int rccConfigFree(rcc_language_config *config) {
 
114
    if (config->charset) {
 
115
        free(config->charset);
 
116
        config->charset = NULL;
 
117
    }
 
118
}
 
119
 
 
120
 
 
121
rcc_language_config *rccGetConfig(rcc_context *ctx, rcc_language_id language_id) {
 
122
    int err;
 
123
 
 
124
    language_id = rccGetRealLanguage(ctx, language_id);
 
125
    if (language_id < 0) return NULL;
 
126
    if (!ctx->configs[language_id].charsets) {
 
127
        if (rccInitConfig(ctx->configs+language_id, ctx)) return NULL;
 
128
    }    
 
129
 
 
130
    ctx->configs[language_id] = ctx->languages[language_id];
 
131
    return ctx->configs + language_id;
 
132
}
 
133
 
 
134
rcc_language_config *rccGetConfigByName(rcc_context *ctx, const char *name) {
 
135
    rcc_language_id language_id;
 
136
    
 
137
    language_id = rccGetLanguageByName(ctx, name);
 
138
    if (language_id < 0) return NULL;
 
139
    
 
140
    return rccGetConfig(ctx, language_id);
 
141
}
 
142
 
 
143
rcc_language_config *rccGetCurrentConfig(rcc_context *ctx) {
 
144
    rcc_language_id language_id;
 
145
    
 
146
    language_id = rccGetCurrentLanguage(ctx);
 
147
    if (language_id < 0) return NULL;
 
148
    
 
149
    return rccGetConfig(ctx, language_id);
 
150
}
 
151
 
 
152
 
 
153
rcc_engine_id rccConfigGetSelectedEngine(rcc_language_config config) {
 
154
    if (!config) return -1;
 
155
    
 
156
    return config->engine;
 
157
}
 
158
 
 
159
const char *rccConfigGetSelectedEngineName(rcc_language_config config) {
 
160
    rcc_engine_id engine_id;
 
161
    
 
162
    engine_id = rccConfigGetSelectedEngine(config);
 
163
    if (engine_id == -1) return rcc_engine_nonconfigured;
 
164
    if ((engine_id < 0)||(!config->language)) return NULL;
 
165
    
 
166
    return rccConfigGetEngineName(config, engine_id);
 
167
}
 
168
 
 
169
rcc_engine_id rccConfigGetCurrentEngine(rcc_language_config config) {
 
170
    rcc_engine_list enginelist;
 
171
    rcc_engine_id engine_id;
 
172
    
 
173
    engine_id = rccConfigGetSelectedEngine(config);
 
174
    if (engine_id>=0) return engine_id;
 
175
 
 
176
    if (!config->language) return NULL;
 
177
    else enginelist = config->language->engines;
 
178
 
 
179
    if (enginelist[0]) {
 
180
        if (enginelist[1]) return 1;
 
181
        return 0;
 
182
    }
 
183
    return -1;
 
184
}
 
185
 
 
186
const char *rccConfigGetCurrentEngineName(rcc_language_config config) {
 
187
    rcc_engine_id engine_id;
 
188
    
 
189
    engine_id = rccConfigGetCurrentEngine(config);
 
190
    if ((engine_id < 0)||(!config->language)) return NULL;
 
191
    
 
192
    return rccConfigGetEngineName(config, engine_id);
 
193
}
 
194
 
 
195
 
 
196
static int rccGetLocaleCharset(char *result, const char *lv, unsigned int n) {
 
197
    char *l;
 
198
 
 
199
    if (!lv) return -1;
 
200
    l = setlocale(lv, NULL);
 
201
    if (!l) return -1;
 
202
    
 
203
    for (i=0;((l[i])&&(l[i]!='.')&&(l[i]!='_'));i++);
 
204
    if (i>=n) return -1;
 
205
    
 
206
    l = strrchr(l, '.');
 
207
    if (!l) return -1;
 
208
 
 
209
    for (i=0;((l[i])&&(l[i]!='@'));i++);
 
210
    if (i>=n) return -1;
 
211
 
 
212
    strncpy(result,l,i);
 
213
    result[i]=0;
 
214
 
 
215
    return 0;
 
216
}
 
217
 
 
218
rcc_charset_id rccConfigGetSelectedCharset(rcc_language_config config, rcc_class_id class_id) {
 
219
    if ((!config)||(!config->ctx)||(class_id<0)||(class_id>=ctx->n_classes)) return -1;
 
220
    
 
221
    return config->charset[class_id];
 
222
}
 
223
 
 
224
const char *rccConfigGetSelectedCharsetName(rcc_language_config config, rcc_class_id class_id) {
 
225
    rcc_charset_id charset_id;
 
226
    
 
227
    charset_id = rccConfigGetSelectedCharset(config, class_id);
 
228
    if ((charset_id < 0)||(!config->language)) return NULL;
 
229
    
 
230
    return rccConfigGetCharsetName(config, charset_id);
 
231
}
 
232
 
 
233
rcc_charset_id rccConfigGetCurrentCharset(rcc_language_config config, rcc_class_id class_id) {
 
234
    int err;
 
235
    unsigned int i;
 
236
    rcc_charset_id charset_id;
 
237
 
 
238
    rcc_language *language;
 
239
    rcc_class *classes;
 
240
    rcc_charset *charsets;
 
241
 
 
242
    char stmp[RCC_MAX_CHARSET_CHARS + 1];
 
243
    char *defvalue;
 
244
    
 
245
    if ((!config)||(!config->ctx)||(class_id<0)||(class_id>=ctx->n_classes)) return NULL;
 
246
    
 
247
    charset_id = ctx->config->charset[class_id];
 
248
    if (charset_id) return charset_id;
 
249
    
 
250
    if (!config->language) return -1;
 
251
    else language = config->language;
 
252
 
 
253
    classes = config->ctx->classes;
 
254
        
 
255
    cl = classes[class_id];
 
256
    defvalue = cl->defvalue;
 
257
    if (defvalue) {
 
258
        for (i=0;classes[i];i++) {
 
259
            if (!strcmp(classes[i]->name, defvalue)) 
 
260
                return rccConfigGetCurrentCharset(config, i); 
 
261
        }
 
262
    } else defvalue = config->ctx->locale_variable;
 
263
    
 
264
    err = rccGetLocaleCharset(stmp, defvalue, RCC_MAX_CHARSET_CHARS);
 
265
    if (err) {
 
266
        charsets=ctx->languages[language_id]->charsets;
 
267
        if ((charsets[0])&&(charsets[1])) return 1;
 
268
        return -1;
 
269
    }
 
270
 
 
271
    return rccConfigGetCharsetByName(config, stmp);
 
272
}
 
273
 
 
274
const char *rccConfigGetCurrentCharsetName(rcc_language_config config, rcc_class_id class_id) {
 
275
    rcc_charset_id charset_id;
 
276
    
 
277
    charset_id = rccConfigGetCurrentCharset(config, class_id);
 
278
    if ((charset_id < 0)||(!config->language)) return NULL;
 
279
    
 
280
    return rccConfigGetCharsetName(config, charset_id);
 
281
}
 
282
 
 
283
rcc_option_value rccConfigGetOption(rcc_language_config config, rcc_option option) {
 
284
    if ((!config)||(option<0)||(option>=RCC_MAX_OPTIONS)) return -1;
 
285
    
 
286
    return config->options[option];
 
287
}
 
288
 
 
289
int rccConfigSetEngine(rcc_language_config *config, rcc_engine_id engine_id) {
 
290
    unsigned int i;
 
291
    
 
292
    if ((!config)||(!config->language)||(engine_id < 0)) return -1;
 
293
 
 
294
    for (i=0;config->language->engines[i];i++);
 
295
    if (engine_id >= i) return -1;
 
296
    
 
297
    if (config->engine != engine_id) {
 
298
        if (config->ctx->current_config == config) config->ctx->configure = 1;
 
299
        config->engine = engine_id;
 
300
    }
 
301
    return 0;
 
302
}
 
303
 
 
304
int rccConfigSetEngineByName(rcc_language_config *config, const char *name) {
 
305
    rcc_engine_id engine_id;
 
306
    
 
307
    engine_id = rccConfigGetEngineByName(config, name);
 
308
    if (engine_id < 0) return -1;
 
309
    
 
310
    return rccConfigSetEngine(config, engine_id);
 
311
}
 
312
 
 
313
int rccConfigSetCharset(rcc_language_config *config, rcc_class_id class_id, rcc_charset_id charset_id) {
 
314
    unsigned int i;
 
315
    
 
316
    if ((!config)||(!config->language)||(class_id < 0)||(class_id >= config->ctx->n_classes)||(charset_id<0)) return -1;
 
317
 
 
318
    for (i=0;config->language->charsets[i];i++);
 
319
    if (charset_id >= i) return -1;
 
320
    
 
321
    if (config->charset[class_id] != charset_id) {
 
322
        if (config->ctx->current_config == config) config->ctx->configure = 1;
 
323
        config->charset[class_id] = charset_id;
 
324
    }
 
325
 
 
326
    return 0;
 
327
}
 
328
 
 
329
int rccConfigSetCharsetByName(rcc_language_config *config, rcc_class_id class_id, const char *name) {
 
330
    rcc_charset_id charset_id;
 
331
    
 
332
    charset_id = rccConfigGetCharsetByName(config, name);
 
333
    if (charset_id < 0) return -1;
 
334
    
 
335
    return rccConfigSetCharset(config, class_id, charset_id);
 
336
}
 
337
 
 
338
int rccConfigSetOption(rcc_language_config *config, rcc_option option, rcc_option_value value) {
 
339
    if ((!config)||(option>=RCC_MAX_OPTIONS)) return -1;
 
340
    if (config->options[option] != value) {
 
341
        if (config->ctx->current_config == config) config->ctx->configure = 1;
 
342
        config->options[option]=value;
 
343
    }
 
344
    
 
345
    return 0;
 
346
}
 
347
 
 
348
rcc_charset_id rccConfigGetLocaleCharset(rcc_language_config *config, const char *locale_variable) {
 
349
    int err;    
 
350
    rcc_charset *charsets;
 
351
    char stmp[RCC_MAX_CHARSET_CHARS+1];
 
352
    
 
353
    if ((!config)||(!config->language)) return -1;
 
354
    
 
355
    err = rccGetLocaleCharset(stmp, locale_variable?locale_variable:config->ctx->locale_variable, RCC_MAX_CHARSET_CHARS);
 
356
    if (err) {
 
357
        charsets=config->language->charsets;
 
358
        if ((charsets[0])&&(charsets[1])) return 1;
 
359
        return -1;
 
360
    }
 
361
 
 
362
    return rccConfigGetCharsetByName(config, stmp);
 
363
}