Build aicasm as host program, not via world's compiler.
[dragonfly.git] / lib / libc / locale / euc.c
1 /*-
2  * Copyright (c) 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Paul Borman at Krystal Technologies.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)euc.c    8.1 (Berkeley) 6/4/93
37  * $FreeBSD: src/lib/libc/locale/euc.c,v 1.3.6.2 2002/08/12 11:17:37 ache Exp $
38  * $DragonFly: src/lib/libc/locale/Attic/euc.c,v 1.3 2003/12/02 14:56:28 eirikn Exp $
39  */
40
41 #include <sys/types.h>
42
43 #include <errno.h>
44 #include <rune.h>
45 #include <stdlib.h>
46
47 rune_t  _EUC_sgetrune(const char *, size_t, char const **);
48 int     _EUC_sputrune(rune_t, char *, size_t, char **);
49
50 typedef struct {
51         int     count[4];
52         rune_t  bits[4];
53         rune_t  mask;
54 } _EucInfo;
55
56 int
57 _EUC_init(rl)
58         _RuneLocale *rl;
59 {
60         _EucInfo *ei;
61         int x, new__mb_cur_max;
62         char *v, *e;
63
64         rl->sgetrune = _EUC_sgetrune;
65         rl->sputrune = _EUC_sputrune;
66
67         if (rl->variable == NULL)
68                 return (EFTYPE);
69
70         v = (char *)rl->variable;
71
72         while (*v == ' ' || *v == '\t')
73                 ++v;
74
75         if ((ei = malloc(sizeof(_EucInfo))) == NULL)
76                 return (errno == 0 ? ENOMEM : errno);
77
78         new__mb_cur_max = 0;
79         for (x = 0; x < 4; ++x) {
80                 ei->count[x] = (int)strtol(v, &e, 0);
81                 if (v == e || !(v = e)) {
82                         free(ei);
83                         return (EFTYPE);
84                 }
85                 if (new__mb_cur_max < ei->count[x])
86                         new__mb_cur_max = ei->count[x];
87                 while (*v == ' ' || *v == '\t')
88                         ++v;
89                 ei->bits[x] = (int)strtol(v, &e, 0);
90                 if (v == e || !(v = e)) {
91                         free(ei);
92                         return (EFTYPE);
93                 }
94                 while (*v == ' ' || *v == '\t')
95                         ++v;
96         }
97         ei->mask = (int)strtol(v, &e, 0);
98         if (v == e || !(v = e)) {
99                 free(ei);
100                 return (EFTYPE);
101         }
102         rl->variable = ei;
103         rl->variable_len = sizeof(_EucInfo);
104         _CurrentRuneLocale = rl;
105         __mb_cur_max = new__mb_cur_max;
106         return (0);
107 }
108
109 #define CEI     ((_EucInfo *)(_CurrentRuneLocale->variable))
110
111 #define _SS2    0x008e
112 #define _SS3    0x008f
113
114 #define GR_BITS 0x80808080 /* XXX: to be fixed */
115
116 static inline int
117 _euc_set(c)
118         u_int c;
119 {
120         c &= 0xff;
121
122         return ((c & 0x80) ? c == _SS3 ? 3 : c == _SS2 ? 2 : 1 : 0);
123 }
124 rune_t
125 _EUC_sgetrune(string, n, result)
126         const char *string;
127         size_t n;
128         char const **result;
129 {
130         rune_t rune = 0;
131         int len, set;
132
133         if (n < 1 || (len = CEI->count[set = _euc_set(*string)]) > n) {
134                 if (result)
135                         *result = string;
136                 return (_INVALID_RUNE);
137         }
138         switch (set) {
139         case 3:
140         case 2:
141                 --len;
142                 ++string;
143                 /* FALLTHROUGH */
144         case 1:
145         case 0:
146                 while (len-- > 0)
147                         rune = (rune << 8) | ((u_int)(*string++) & 0xff);
148                 break;
149         }
150         if (result)
151                 *result = string;
152         return ((rune & ~CEI->mask) | CEI->bits[set]);
153 }
154
155 int
156 _EUC_sputrune(c, string, n, result)
157         rune_t c;
158         char *string, **result;
159         size_t n;
160 {
161         rune_t m = c & CEI->mask;
162         rune_t nm = c & ~m;
163         int i, len;
164
165         if (m == CEI->bits[1]) {
166 CodeSet1:
167                 /* Codeset 1: The first byte must have 0x80 in it. */
168                 i = len = CEI->count[1];
169                 if (n >= len) {
170                         if (result)
171                                 *result = string + len;
172                         while (i-- > 0)
173                                 *string++ = (nm >> (i << 3)) | 0x80;
174                 } else
175                         if (result)
176                                 *result = (char *) 0;
177         } else {
178                 if (m == CEI->bits[0]) {
179                         i = len = CEI->count[0];
180                         if (n < len) {
181                                 if (result)
182                                         *result = NULL;
183                                 return (len);
184                         }
185                 } else
186                         if (m == CEI->bits[2]) {
187                                 i = len = CEI->count[2];
188                                 if (n < len) {
189                                         if (result)
190                                                 *result = NULL;
191                                         return (len);
192                                 }
193                                 *string++ = _SS2;
194                                 --i;
195                                 /* SS2 designates G2 into GR */
196                                 nm |= GR_BITS;
197                         } else
198                                 if (m == CEI->bits[3]) {
199                                         i = len = CEI->count[3];
200                                         if (n < len) {
201                                                 if (result)
202                                                         *result = NULL;
203                                                 return (len);
204                                         }
205                                         *string++ = _SS3;
206                                         --i;
207                                         /* SS3 designates G3 into GR */
208                                         nm |= GR_BITS;
209                                 } else
210                                         goto CodeSet1;  /* Bletch */
211                 while (i-- > 0)
212                         *string++ = (nm >> (i << 3)) & 0xff;
213                 if (result)
214                         *result = string;
215         }
216         return (len);
217 }