ncurses 6.0 - patch 20170812
[ncurses.git] / ncurses / tinfo / obsolete.c
1 /****************************************************************************
2  * Copyright (c) 2013-2014,2016 Free Software Foundation, Inc.              *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /****************************************************************************
30  *  Author: Thomas E. Dickey                        2013-on                 *
31  ****************************************************************************/
32
33 /*
34 **      Support for obsolete/unusual features.
35 */
36
37 #include <curses.priv.h>
38
39 MODULE_ID("$Id: obsolete.c,v 1.4 2016/09/10 18:39:51 tom Exp $")
40
41 /*
42  * Obsolete entrypoint retained for binary compatbility.
43  */
44 NCURSES_EXPORT(void)
45 NCURSES_SP_NAME(_nc_set_buffer) (NCURSES_SP_DCLx FILE *ofp, int buffered)
46 {
47 #if NCURSES_SP_FUNCS
48     (void) SP_PARM;
49 #endif
50     (void) ofp;
51     (void) buffered;
52 }
53
54 #if NCURSES_SP_FUNCS
55 NCURSES_EXPORT(void)
56 _nc_set_buffer(FILE *ofp, int buffered)
57 {
58     NCURSES_SP_NAME(_nc_set_buffer) (CURRENT_SCREEN, ofp, buffered);
59 }
60 #endif
61
62 #if !HAVE_STRDUP
63 NCURSES_EXPORT(char *)
64 _nc_strdup(const char *s)
65 {
66     char *result = 0;
67     if (s != 0) {
68         size_t need = strlen(s);
69         result = malloc(need + 1);
70         if (result != 0) {
71             _nc_STRCPY(result, s, need);
72         }
73     }
74     return result;
75 }
76 #endif
77
78 #if USE_MY_MEMMOVE
79 #define DST ((char *)s1)
80 #define SRC ((const char *)s2)
81 NCURSES_EXPORT(void *)
82 _nc_memmove(void *s1, const void *s2, size_t n)
83 {
84     if (n != 0) {
85         if ((DST + n > SRC) && (SRC + n > DST)) {
86             static char *bfr;
87             static size_t length;
88             register size_t j;
89             if (length < n) {
90                 length = (n * 3) / 2;
91                 bfr = typeRealloc(char, length, bfr);
92             }
93             for (j = 0; j < n; j++)
94                 bfr[j] = SRC[j];
95             s2 = bfr;
96         }
97         while (n-- != 0)
98             DST[n] = SRC[n];
99     }
100     return s1;
101 }
102 #endif /* USE_MY_MEMMOVE */
103
104 #ifdef EXP_XTERM_1005
105 NCURSES_EXPORT(int)
106 _nc_conv_to_utf8(unsigned char *target, unsigned source, unsigned limit)
107 {
108 #define CH(n) UChar((source) >> ((n) * 8))
109     int rc = 0;
110
111     if (source <= 0x0000007f)
112         rc = 1;
113     else if (source <= 0x000007ff)
114         rc = 2;
115     else if (source <= 0x0000ffff)
116         rc = 3;
117     else if (source <= 0x001fffff)
118         rc = 4;
119     else if (source <= 0x03ffffff)
120         rc = 5;
121     else                        /* (source <= 0x7fffffff) */
122         rc = 6;
123
124     if ((unsigned) rc > limit) {        /* whatever it is, we cannot decode it */
125         rc = 0;
126     }
127
128     if (target != 0) {
129         switch (rc) {
130         case 1:
131             target[0] = CH(0);
132             break;
133
134         case 2:
135             target[1] = UChar(0x80 | (CH(0) & 0x3f));
136             target[0] = UChar(0xc0 | (CH(0) >> 6) | ((CH(1) & 0x07) << 2));
137             break;
138
139         case 3:
140             target[2] = UChar(0x80 | (CH(0) & 0x3f));
141             target[1] = UChar(0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
142             target[0] = UChar(0xe0 | ((int) (CH(1) & 0xf0) >> 4));
143             break;
144
145         case 4:
146             target[3] = UChar(0x80 | (CH(0) & 0x3f));
147             target[2] = UChar(0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
148             target[1] = UChar(0x80 |
149                               ((int) (CH(1) & 0xf0) >> 4) |
150                               ((int) (CH(2) & 0x03) << 4));
151             target[0] = UChar(0xf0 | ((int) (CH(2) & 0x1f) >> 2));
152             break;
153
154         case 5:
155             target[4] = UChar(0x80 | (CH(0) & 0x3f));
156             target[3] = UChar(0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
157             target[2] = UChar(0x80 |
158                               ((int) (CH(1) & 0xf0) >> 4) |
159                               ((int) (CH(2) & 0x03) << 4));
160             target[1] = UChar(0x80 | (CH(2) >> 2));
161             target[0] = UChar(0xf8 | (CH(3) & 0x03));
162             break;
163
164         case 6:
165             target[5] = UChar(0x80 | (CH(0) & 0x3f));
166             target[4] = UChar(0x80 | (CH(0) >> 6) | ((CH(1) & 0x0f) << 2));
167             target[3] = UChar(0x80 | (CH(1) >> 4) | ((CH(2) & 0x03) << 4));
168             target[2] = UChar(0x80 | (CH(2) >> 2));
169             target[1] = UChar(0x80 | (CH(3) & 0x3f));
170             target[0] = UChar(0xfc | ((int) (CH(3) & 0x40) >> 6));
171             break;
172         }
173     }
174
175     return rc;                  /* number of bytes needed in target */
176 #undef CH
177 }
178
179 NCURSES_EXPORT(int)
180 _nc_conv_to_utf32(unsigned *target, const char *source, unsigned limit)
181 {
182 #define CH(n) UChar((*target) >> ((n) * 8))
183     int rc = 0;
184     int j;
185     unsigned mask = 0;
186
187     /*
188      * Find the number of bytes we will need from the source.
189      */
190     if ((*source & 0x80) == 0) {
191         rc = 1;
192         mask = (unsigned) *source;
193     } else if ((*source & 0xe0) == 0xc0) {
194         rc = 2;
195         mask = (unsigned) (*source & 0x1f);
196     } else if ((*source & 0xf0) == 0xe0) {
197         rc = 3;
198         mask = (unsigned) (*source & 0x0f);
199     } else if ((*source & 0xf8) == 0xf0) {
200         rc = 4;
201         mask = (unsigned) (*source & 0x07);
202     } else if ((*source & 0xfc) == 0xf8) {
203         rc = 5;
204         mask = (unsigned) (*source & 0x03);
205     } else if ((*source & 0xfe) == 0xfc) {
206         rc = 6;
207         mask = (unsigned) (*source & 0x01);
208     }
209
210     if ((unsigned) rc > limit) {        /* whatever it is, we cannot decode it */
211         rc = 0;
212     }
213
214     /*
215      * sanity-check.
216      */
217     if (rc > 1) {
218         for (j = 1; j < rc; j++) {
219             if ((source[j] & 0xc0) != 0x80)
220                 break;
221         }
222         if (j != rc) {
223             rc = 0;
224         }
225     }
226
227     if (target != 0) {
228         int shift = 0;
229         *target = 0;
230         for (j = 1; j < rc; j++) {
231             *target |= (unsigned) (source[rc - j] & 0x3f) << shift;
232             shift += 6;
233         }
234         *target |= mask << shift;
235     }
236     return rc;
237 #undef CH
238 }
239 #endif /* EXP_XTERM_1005 */