Debian Codegraph @

src/backend/utils/adt/char.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * char.c
4 * Functions for the built-in type "char" (not to be confused with
5 * bpchar, which is the SQL CHAR(n) type).
6 *
7 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
9 *
10 *
11 * IDENTIFICATION
12 * src/backend/utils/adt/char.c
13 *
14 *-------------------------------------------------------------------------
15 */
16 #include "postgres.h"
17
18 #include <limits.h>
19
20 #include "libpq/pqformat.h"
21 #include "utils/fmgrprotos.h"
22 #include "varatt.h"
23
24 #define ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))
25 #define TOOCTAL(c) ((c) + '0')
26 #define FROMOCTAL(c) ((unsigned char) (c) - '0')
27
28
29 /*****************************************************************************
30 * USER I/O ROUTINES *
31 *****************************************************************************/
32
33 /*
34 * charin - converts "x" to 'x'
35 *
36 * This accepts the formats charout produces. If we have multibyte input
37 * that is not in the form '\ooo', then we take its first byte as the value
38 * and silently discard the rest; this is a backwards-compatibility provision.
39 */
40 Datum
41 charin(PG_FUNCTION_ARGS)
42 {
43 char *ch = PG_GETARG_CSTRING(0);
44
45 if (strlen(ch) == 4 && ch[0] == '\\' &&
46 ISOCTAL(ch[1]) && ISOCTAL(ch[2]) && ISOCTAL(ch[3]))
47 PG_RETURN_CHAR((FROMOCTAL(ch[1]) << 6) +
48 (FROMOCTAL(ch[2]) << 3) +
49 FROMOCTAL(ch[3]));
50 /* This will do the right thing for a zero-length input string */
51 PG_RETURN_CHAR(ch[0]);
52 }
53
54 /*
55 * charout - converts 'x' to "x"
56 *
57 * The possible output formats are:
58 * 1. 0x00 is represented as an empty string.
59 * 2. 0x01..0x7F are represented as a single ASCII byte.
60 * 3. 0x80..0xFF are represented as \ooo (backslash and 3 octal digits).
61 * Case 3 is meant to match the traditional "escape" format of bytea.
62 */
63 Datum
64 charout(PG_FUNCTION_ARGS)
65 {
66 char ch = PG_GETARG_CHAR(0);
67 char *result = (char *) palloc(5);
68
69 if (IS_HIGHBIT_SET(ch))
70 {
71 result[0] = '\\';
72 result[1] = TOOCTAL(((unsigned char) ch) >> 6);
73 result[2] = TOOCTAL((((unsigned char) ch) >> 3) & 07);
74 result[3] = TOOCTAL(((unsigned char) ch) & 07);
75 result[4] = '\0';
76 }
77 else
78 {
79 /* This produces acceptable results for 0x00 as well */
80 result[0] = ch;
81 result[1] = '\0';
82 }
83 PG_RETURN_CSTRING(result);
84 }
85
86 /*
87 * charrecv - converts external binary format to char
88 *
89 * The external representation is one byte, with no character set
90 * conversion. This is somewhat dubious, perhaps, but in many
91 * cases people use char for a 1-byte binary type.
92 */
93 Datum
94 charrecv(PG_FUNCTION_ARGS)
95 {
96 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
97
98 PG_RETURN_CHAR(pq_getmsgbyte(buf));
99 }
100
101 /*
102 * charsend - converts char to binary format
103 */
104 Datum
105 charsend(PG_FUNCTION_ARGS)
106 {
107 char arg1 = PG_GETARG_CHAR(0);
108 StringInfoData buf;
109
110 pq_begintypsend(&buf);
111 pq_sendbyte(&buf, arg1);
112 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
113 }
114
115 /*****************************************************************************
116 * PUBLIC ROUTINES *
117 *****************************************************************************/
118
119 /*
120 * NOTE: comparisons are done as though char is unsigned (uint8).
121 * Conversions to and from integer are done as though char is signed (int8).
122 *
123 * You wanted consistency?
124 */
125
126 Datum
127 chareq(PG_FUNCTION_ARGS)
128 {
129 char arg1 = PG_GETARG_CHAR(0);
130 char arg2 = PG_GETARG_CHAR(1);
131
132 PG_RETURN_BOOL(arg1 == arg2);
133 }
134
135 Datum
136 charne(PG_FUNCTION_ARGS)
137 {
138 char arg1 = PG_GETARG_CHAR(0);
139 char arg2 = PG_GETARG_CHAR(1);
140
141 PG_RETURN_BOOL(arg1 != arg2);
142 }
143
144 Datum
145 charlt(PG_FUNCTION_ARGS)
146 {
147 char arg1 = PG_GETARG_CHAR(0);
148 char arg2 = PG_GETARG_CHAR(1);
149
150 PG_RETURN_BOOL((uint8) arg1 < (uint8) arg2);
151 }
152
153 Datum
154 charle(PG_FUNCTION_ARGS)
155 {
156 char arg1 = PG_GETARG_CHAR(0);
157 char arg2 = PG_GETARG_CHAR(1);
158
159 PG_RETURN_BOOL((uint8) arg1 <= (uint8) arg2);
160 }
161
162 Datum
163 chargt(PG_FUNCTION_ARGS)
164 {
165 char arg1 = PG_GETARG_CHAR(0);
166 char arg2 = PG_GETARG_CHAR(1);
167
168 PG_RETURN_BOOL((uint8) arg1 > (uint8) arg2);
169 }
170
171 Datum
172 charge(PG_FUNCTION_ARGS)
173 {
174 char arg1 = PG_GETARG_CHAR(0);
175 char arg2 = PG_GETARG_CHAR(1);
176
177 PG_RETURN_BOOL((uint8) arg1 >= (uint8) arg2);
178 }
179
180
181 Datum
182 chartoi4(PG_FUNCTION_ARGS)
183 {
184 char arg1 = PG_GETARG_CHAR(0);
185
186 PG_RETURN_INT32((int32) ((int8) arg1));
187 }
188
189 Datum
190 i4tochar(PG_FUNCTION_ARGS)
191 {
192 int32 arg1 = PG_GETARG_INT32(0);
193
194 if (arg1 < SCHAR_MIN || arg1 > SCHAR_MAX)
195 ereport(ERROR,
196 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
197 errmsg("\"char\" out of range")));
198
199 PG_RETURN_CHAR((int8) arg1);
200 }
201
202
203 Datum
204 text_char(PG_FUNCTION_ARGS)
205 {
206 text *arg1 = PG_GETARG_TEXT_PP(0);
207 char *ch = VARDATA_ANY(arg1);
208 char result;
209
210 /*
211 * Conversion rules are the same as in charin(), but here we need to
212 * handle the empty-string case honestly.
213 */
214 if (VARSIZE_ANY_EXHDR(arg1) == 4 && ch[0] == '\\' &&
215 ISOCTAL(ch[1]) && ISOCTAL(ch[2]) && ISOCTAL(ch[3]))
216 result = (FROMOCTAL(ch[1]) << 6) +
217 (FROMOCTAL(ch[2]) << 3) +
218 FROMOCTAL(ch[3]);
219 else if (VARSIZE_ANY_EXHDR(arg1) > 0)
220 result = ch[0];
221 else
222 result = '\0';
223
224 PG_RETURN_CHAR(result);
225 }
226
227 Datum
228 char_text(PG_FUNCTION_ARGS)
229 {
230 char arg1 = PG_GETARG_CHAR(0);
231 text *result = palloc(VARHDRSZ + 4);
232
233 /*
234 * Conversion rules are the same as in charout(), but here we need to be
235 * honest about converting 0x00 to an empty string.
236 */
237 if (IS_HIGHBIT_SET(arg1))
238 {
239 SET_VARSIZE(result, VARHDRSZ + 4);
240 (VARDATA(result))[0] = '\\';
241 (VARDATA(result))[1] = TOOCTAL(((unsigned char) arg1) >> 6);
242 (VARDATA(result))[2] = TOOCTAL((((unsigned char) arg1) >> 3) & 07);
243 (VARDATA(result))[3] = TOOCTAL(((unsigned char) arg1) & 07);
244 }
245 else if (arg1 != '\0')
246 {
247 SET_VARSIZE(result, VARHDRSZ + 1);
248 *(VARDATA(result)) = arg1;
249 }
250 else
251 SET_VARSIZE(result, VARHDRSZ);
252
253 PG_RETURN_TEXT_P(result);
254 }