/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/rcctranslate.c

  • Committer: Suren A. Chilingaryan
  • Date: 2005-07-29 03:26:28 UTC
  • Revision ID: Arch-1:ds@dside.dyndns.org--darksoft-2004%librcc--main--0.1--patch-23
Translation
    - Language Translation using libtranslate is implemented
    - Autoengine sets current charset (option)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/rcctranslate.c
 
1
#include <stdio.h>
 
2
#include <stdlib.h>
 
3
#include <string.h>
 
4
 
 
5
#include "internal.h"
 
6
#include "rccexternal.h"
 
7
#include "rcctranslate.h"
 
8
 
 
9
 
 
10
 
 
11
int rccTranslateInit() {
 
12
 
 
13
    return 0;
 
14
}
 
15
 
 
16
void rccTranslateFree() {
 
17
}
 
18
 
 
19
 
 
20
rcc_translate rccTranslateOpen(const char *from, const char *to) {
 
21
#ifdef HAVE_LIBTRANSLATE
 
22
    rcc_translate translate;
 
23
 
 
24
    if ((!from)||(!to)||(!strcasecmp(from,to))) return NULL;
 
25
    if ((strlen(from)!=2)||(strlen(to)!=2)) return NULL;
 
26
    
 
27
    translate = (rcc_translate)malloc(sizeof(rcc_translate_s));
 
28
    if (!translate) return NULL;
 
29
 
 
30
    translate->sock = rccExternalConnect(RCC_EXTERNAL_MODULE_LIBRTRANSLATE);
 
31
    if (translate->sock == -1) {
 
32
        free(translate);
 
33
        return NULL;
 
34
    }
 
35
 
 
36
    translate->remaining = 0;
 
37
    translate->prefix.cmd.cmd = RCC_EXTERNAL_COMMAND_TRANSLATE;
 
38
    translate->prefix.cmd.size = sizeof(rcc_translate_prefix_s);
 
39
    memcpy(translate->prefix.from, from, 3*sizeof(char));
 
40
    memcpy(translate->prefix.to, to,  3*sizeof(char));
 
41
    rccTranslateSetTimeout(translate, RCC_TRANSLATE_DEFAULT_TIMEOUT);
 
42
 
 
43
    return translate;
 
44
#else
 
45
    return NULL;
 
46
#endif /* HAVE_LIBTRANSLATE */
 
47
}
 
48
 
 
49
void rccTranslateClose(rcc_translate translate) {
 
50
#ifdef HAVE_LIBTRANSLATE
 
51
    if (!translate) return;
 
52
    if (translate->sock != -1) rccExternalClose(translate->sock);
 
53
    free(translate);
 
54
#endif /* HAVE_LIBTRANSLATE */
 
55
}
 
56
 
 
57
int rccTranslateSetTimeout(rcc_translate translate, unsigned long us) {
 
58
#ifdef HAVE_LIBTRANSLATE_TIMED_TRANSLATE    
 
59
    if (!translate) return -1;
 
60
    translate->prefix.timeout = us;
 
61
    return 0;
 
62
#else
 
63
    return -1;
 
64
#endif /* HAVE_LIBTRANSLATE_TIMED_TRANSLATE */
 
65
}
 
66
 
 
67
char *rccTranslate(rcc_translate translate, const char *buf) {
 
68
#ifdef HAVE_LIBTRANSLATE
 
69
    size_t i;
 
70
    rcc_external_command_s resp;
 
71
    size_t err, len;
 
72
    char *buffer;
 
73
 
 
74
    if ((!translate)||(!buf)) return NULL;
 
75
    
 
76
    if (!strcmp(translate->prefix.to, "en")) {
 
77
        for (i=0;buf[i];i++) 
 
78
            if ((unsigned char)buf[i]>0x7F) break;
 
79
        if (!buf[i]) return NULL;
 
80
    }
 
81
    
 
82
    if (translate->sock == -1) {
 
83
        translate->sock = rccExternalConnect(RCC_EXTERNAL_MODULE_LIBRTRANSLATE);
 
84
        if (translate->sock == -1) return NULL;
 
85
    } else if (translate->remaining) {
 
86
        if (translate->remaining == (size_t)-1) {
 
87
            err = rccExternalRead(translate->sock, (char*)&resp, sizeof(rcc_external_command_s), 0);
 
88
            if (err) return NULL;
 
89
            translate->remaining = resp.size;
 
90
        }
 
91
        
 
92
        buffer = (char*)malloc(translate->remaining*sizeof(char));
 
93
        if (!buffer) {
 
94
            rccExternalClose(translate->sock);
 
95
            translate->sock = -1;
 
96
            return NULL;
 
97
        }
 
98
        err = rccExternalRead(translate->sock, buffer, translate->remaining, 0);
 
99
        free(buffer);
 
100
        if (err) {
 
101
            translate->remaining = err;
 
102
            return NULL;
 
103
        }
 
104
        translate->remaining = 0;
 
105
    }
 
106
    
 
107
    len = strlen(buf);
 
108
    translate->prefix.cmd.size = sizeof(rcc_translate_prefix_s) + len - sizeof(rcc_external_command_s);
 
109
    err = rccExternalWrite(translate->sock, (char*)&translate->prefix, sizeof(rcc_translate_prefix_s) - 1, 0);
 
110
    if (err) {
 
111
        rccExternalClose(translate->sock);
 
112
        translate->sock = -1;
 
113
        return NULL;
 
114
    }
 
115
    err = rccExternalWrite(translate->sock, buf, len + 1, 0);
 
116
    if (err) {
 
117
        rccExternalClose(translate->sock);
 
118
        translate->sock = -1;
 
119
        return NULL;
 
120
    }
 
121
 
 
122
    err = rccExternalRead(translate->sock, (char*)&resp, sizeof(rcc_external_command_s), translate->prefix.timeout);
 
123
    if (err) {
 
124
        if (err == sizeof(rcc_external_command_s)) {
 
125
            translate->remaining = (size_t)-1;
 
126
        } else {
 
127
            rccExternalClose(translate->sock);
 
128
            translate->sock = -1;
 
129
        }
 
130
        return NULL;
 
131
    }
 
132
    if ((resp.cmd!=RCC_EXTERNAL_COMMAND_TRANSLATE)||(!resp.size)) return NULL;
 
133
    
 
134
    buffer = (char*)malloc(resp.size*sizeof(char));
 
135
    if (!buffer) {
 
136
        rccExternalClose(translate->sock);
 
137
        translate->sock = -1;
 
138
        return NULL;
 
139
    }
 
140
    err = rccExternalRead(translate->sock, buffer, resp.size, 0);
 
141
    if (err) {
 
142
        translate->remaining = err;
 
143
        free(buffer);
 
144
        return NULL;
 
145
    }
 
146
    
 
147
    return buffer;
 
148
#else
 
149
    return NULL;
 
150
#endif /* HAVE_LIBTRANSLATE */
 
151
}