PostgreSQL Source Code git master
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
encode.c File Reference
#include "postgres.h"
#include <ctype.h>
#include "mb/pg_wchar.h"
#include "utils/builtins.h"
#include "utils/memutils.h"
#include "varatt.h"
Include dependency graph for encode.c:

Go to the source code of this file.

Data Structures

struct  pg_encoding
 

Macros

#define VAL(CH)   ((CH) - '0')
 
#define DIG(VAL)   ((VAL) + '0')
 

Functions

static const struct pg_encodingpg_find_encoding (const char *name)
 
Datum binary_encode (PG_FUNCTION_ARGS)
 
Datum binary_decode (PG_FUNCTION_ARGS)
 
uint64 hex_encode (const char *src, size_t len, char *dst)
 
static bool get_hex (const char *cp, char *out)
 
uint64 hex_decode (const char *src, size_t len, char *dst)
 
uint64 hex_decode_safe (const char *src, size_t len, char *dst, Node *escontext)
 
static uint64 hex_enc_len (const char *src, size_t srclen)
 
static uint64 hex_dec_len (const char *src, size_t srclen)
 
static uint64 pg_base64_encode (const char *src, size_t len, char *dst)
 
static uint64 pg_base64_decode (const char *src, size_t len, char *dst)
 
static uint64 pg_base64_enc_len (const char *src, size_t srclen)
 
static uint64 pg_base64_dec_len (const char *src, size_t srclen)
 
static uint64 esc_encode (const char *src, size_t srclen, char *dst)
 
static uint64 esc_decode (const char *src, size_t srclen, char *dst)
 
static uint64 esc_enc_len (const char *src, size_t srclen)
 
static uint64 esc_dec_len (const char *src, size_t srclen)
 

Variables

static const char hextbl [512]
 
static const int8 hexlookup [128]
 
static const char _base64 []
 
static const int8 b64lookup [128]
 
struct {
   const char *   name
 
   struct pg_encoding   enc
 
enclist []
 

Macro Definition Documentation

◆ DIG

#define DIG (   VAL)    ((VAL) + '0')

Definition at line 433 of file encode.c.

◆ VAL

#define VAL (   CH)    ((CH) - '0')

Definition at line 432 of file encode.c.

Function Documentation

◆ binary_decode()

Datum binary_decode ( PG_FUNCTION_ARGS  )

Definition at line 96 of file encode.c.

97{
100 bytea *result;
101 char *namebuf;
102 char *dataptr;
103 size_t datalen;
104 uint64 resultlen;
105 uint64 res;
106 const struct pg_encoding *enc;
107
108 namebuf = TextDatumGetCString(name);
109
110 enc = pg_find_encoding(namebuf);
111 if (enc == NULL)
113 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
114 errmsg("unrecognized encoding: \"%s\"", namebuf)));
115
116 dataptr = VARDATA_ANY(data);
117 datalen = VARSIZE_ANY_EXHDR(data);
118
119 resultlen = enc->decode_len(dataptr, datalen);
120
121 /*
122 * resultlen possibly overflows uint32, therefore on 32-bit machines it's
123 * unsafe to rely on palloc's internal check.
124 */
125 if (resultlen > MaxAllocSize - VARHDRSZ)
127 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
128 errmsg("result of decoding conversion is too large")));
129
130 result = palloc(VARHDRSZ + resultlen);
131
132 res = enc->decode(dataptr, datalen, VARDATA(result));
133
134 /* Make this FATAL 'cause we've trodden on memory ... */
135 if (res > resultlen)
136 elog(FATAL, "overflow - decode estimate too small");
137
138 SET_VARSIZE(result, VARHDRSZ + res);
139
140 PG_RETURN_BYTEA_P(result);
141}
#define TextDatumGetCString(d)
Definition: builtins.h:98
#define VARHDRSZ
Definition: c.h:663
uint64_t uint64
Definition: c.h:503
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define FATAL
Definition: elog.h:41
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define ereport(elevel,...)
Definition: elog.h:149
static const struct pg_encoding * pg_find_encoding(const char *name)
Definition: encode.c:624
const char * name
Definition: encode.c:592
struct pg_encoding enc
Definition: encode.c:593
#define MaxAllocSize
Definition: fe_memutils.h:22
#define PG_GETARG_TEXT_PP(n)
Definition: fmgr.h:309
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:371
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:268
void * palloc(Size size)
Definition: mcxt.c:1940
const void * data
uintptr_t Datum
Definition: postgres.h:69
uint64(* decode_len)(const char *data, size_t dlen)
Definition: encode.c:36
uint64(* decode)(const char *data, size_t dlen, char *res)
Definition: encode.c:38
Definition: c.h:658
#define VARDATA(PTR)
Definition: varatt.h:278
#define VARDATA_ANY(PTR)
Definition: varatt.h:324
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305
#define VARSIZE_ANY_EXHDR(PTR)
Definition: varatt.h:317

References data, pg_encoding::decode, pg_encoding::decode_len, elog, enc, ereport, errcode(), errmsg(), ERROR, FATAL, MaxAllocSize, name, palloc(), pg_find_encoding(), PG_GETARG_DATUM, PG_GETARG_TEXT_PP, PG_RETURN_BYTEA_P, SET_VARSIZE, TextDatumGetCString, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

◆ binary_encode()

Datum binary_encode ( PG_FUNCTION_ARGS  )

Definition at line 48 of file encode.c.

49{
52 text *result;
53 char *namebuf;
54 char *dataptr;
55 size_t datalen;
56 uint64 resultlen;
57 uint64 res;
58 const struct pg_encoding *enc;
59
60 namebuf = TextDatumGetCString(name);
61
62 enc = pg_find_encoding(namebuf);
63 if (enc == NULL)
65 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
66 errmsg("unrecognized encoding: \"%s\"", namebuf)));
67
68 dataptr = VARDATA_ANY(data);
69 datalen = VARSIZE_ANY_EXHDR(data);
70
71 resultlen = enc->encode_len(dataptr, datalen);
72
73 /*
74 * resultlen possibly overflows uint32, therefore on 32-bit machines it's
75 * unsafe to rely on palloc's internal check.
76 */
77 if (resultlen > MaxAllocSize - VARHDRSZ)
79 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
80 errmsg("result of encoding conversion is too large")));
81
82 result = palloc(VARHDRSZ + resultlen);
83
84 res = enc->encode(dataptr, datalen, VARDATA(result));
85
86 /* Make this FATAL 'cause we've trodden on memory ... */
87 if (res > resultlen)
88 elog(FATAL, "overflow - encode estimate too small");
89
90 SET_VARSIZE(result, VARHDRSZ + res);
91
92 PG_RETURN_TEXT_P(result);
93}
#define PG_GETARG_BYTEA_PP(n)
Definition: fmgr.h:308
#define PG_RETURN_TEXT_P(x)
Definition: fmgr.h:372
uint64(* encode_len)(const char *data, size_t dlen)
Definition: encode.c:35
uint64(* encode)(const char *data, size_t dlen, char *res)
Definition: encode.c:37

References data, elog, enc, pg_encoding::encode, pg_encoding::encode_len, ereport, errcode(), errmsg(), ERROR, FATAL, MaxAllocSize, name, palloc(), pg_find_encoding(), PG_GETARG_BYTEA_PP, PG_GETARG_DATUM, PG_RETURN_TEXT_P, SET_VARSIZE, TextDatumGetCString, VARDATA, VARDATA_ANY, VARHDRSZ, and VARSIZE_ANY_EXHDR.

◆ esc_dec_len()

static uint64 esc_dec_len ( const char *  src,
size_t  srclen 
)
static

Definition at line 544 of file encode.c.

545{
546 const char *end = src + srclen;
547 uint64 len = 0;
548
549 while (src < end)
550 {
551 if (src[0] != '\\')
552 src++;
553 else if (src + 3 < end &&
554 (src[1] >= '0' && src[1] <= '3') &&
555 (src[2] >= '0' && src[2] <= '7') &&
556 (src[3] >= '0' && src[3] <= '7'))
557 {
558 /*
559 * backslash + valid octal
560 */
561 src += 4;
562 }
563 else if (src + 1 < end &&
564 (src[1] == '\\'))
565 {
566 /*
567 * two backslashes = backslash
568 */
569 src += 2;
570 }
571 else
572 {
573 /*
574 * one backslash, not followed by ### valid octal
575 */
577 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
578 errmsg("invalid input syntax for type %s", "bytea")));
579 }
580
581 len++;
582 }
583 return len;
584}
const void size_t len

References ereport, errcode(), errmsg(), ERROR, and len.

◆ esc_decode()

static uint64 esc_decode ( const char *  src,
size_t  srclen,
char *  dst 
)
static

Definition at line 475 of file encode.c.

476{
477 const char *end = src + srclen;
478 char *rp = dst;
479 uint64 len = 0;
480
481 while (src < end)
482 {
483 if (src[0] != '\\')
484 *rp++ = *src++;
485 else if (src + 3 < end &&
486 (src[1] >= '0' && src[1] <= '3') &&
487 (src[2] >= '0' && src[2] <= '7') &&
488 (src[3] >= '0' && src[3] <= '7'))
489 {
490 int val;
491
492 val = VAL(src[1]);
493 val <<= 3;
494 val += VAL(src[2]);
495 val <<= 3;
496 *rp++ = val + VAL(src[3]);
497 src += 4;
498 }
499 else if (src + 1 < end &&
500 (src[1] == '\\'))
501 {
502 *rp++ = '\\';
503 src += 2;
504 }
505 else
506 {
507 /*
508 * One backslash, not followed by ### valid octal. Should never
509 * get here, since esc_dec_len does same check.
510 */
512 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
513 errmsg("invalid input syntax for type %s", "bytea")));
514 }
515
516 len++;
517 }
518
519 return len;
520}
#define VAL(CH)
Definition: encode.c:432
long val
Definition: informix.c:689

References ereport, errcode(), errmsg(), ERROR, len, VAL, and val.

◆ esc_enc_len()

static uint64 esc_enc_len ( const char *  src,
size_t  srclen 
)
static

Definition at line 523 of file encode.c.

524{
525 const char *end = src + srclen;
526 uint64 len = 0;
527
528 while (src < end)
529 {
530 if (*src == '\0' || IS_HIGHBIT_SET(*src))
531 len += 4;
532 else if (*src == '\\')
533 len += 2;
534 else
535 len++;
536
537 src++;
538 }
539
540 return len;
541}
#define IS_HIGHBIT_SET(ch)
Definition: c.h:1126

References IS_HIGHBIT_SET, and len.

◆ esc_encode()

static uint64 esc_encode ( const char *  src,
size_t  srclen,
char *  dst 
)
static

Definition at line 436 of file encode.c.

437{
438 const char *end = src + srclen;
439 char *rp = dst;
440 uint64 len = 0;
441
442 while (src < end)
443 {
444 unsigned char c = (unsigned char) *src;
445
446 if (c == '\0' || IS_HIGHBIT_SET(c))
447 {
448 rp[0] = '\\';
449 rp[1] = DIG(c >> 6);
450 rp[2] = DIG((c >> 3) & 7);
451 rp[3] = DIG(c & 7);
452 rp += 4;
453 len += 4;
454 }
455 else if (c == '\\')
456 {
457 rp[0] = '\\';
458 rp[1] = '\\';
459 rp += 2;
460 len += 2;
461 }
462 else
463 {
464 *rp++ = c;
465 len++;
466 }
467
468 src++;
469 }
470
471 return len;
472}
#define DIG(VAL)
Definition: encode.c:433
char * c

References DIG, IS_HIGHBIT_SET, and len.

◆ get_hex()

static bool get_hex ( const char *  cp,
char *  out 
)
inlinestatic

Definition at line 197 of file encode.c.

198{
199 unsigned char c = (unsigned char) *cp;
200 int res = -1;
201
202 if (c < 127)
203 res = hexlookup[c];
204
205 *out = (char) res;
206
207 return (res >= 0);
208}
static const int8 hexlookup[128]
Definition: encode.c:169

References hexlookup.

Referenced by hex_decode_safe().

◆ hex_dec_len()

static uint64 hex_dec_len ( const char *  src,
size_t  srclen 
)
static

Definition at line 264 of file encode.c.

265{
266 return (uint64) srclen >> 1;
267}

◆ hex_decode()

uint64 hex_decode ( const char *  src,
size_t  len,
char *  dst 
)

Definition at line 211 of file encode.c.

212{
213 return hex_decode_safe(src, len, dst, NULL);
214}
uint64 hex_decode_safe(const char *src, size_t len, char *dst, Node *escontext)
Definition: encode.c:217

References hex_decode_safe(), and len.

◆ hex_decode_safe()

uint64 hex_decode_safe ( const char *  src,
size_t  len,
char *  dst,
Node escontext 
)

Definition at line 217 of file encode.c.

218{
219 const char *s,
220 *srcend;
221 char v1,
222 v2,
223 *p;
224
225 srcend = src + len;
226 s = src;
227 p = dst;
228 while (s < srcend)
229 {
230 if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
231 {
232 s++;
233 continue;
234 }
235 if (!get_hex(s, &v1))
236 ereturn(escontext, 0,
237 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
238 errmsg("invalid hexadecimal digit: \"%.*s\"",
239 pg_mblen(s), s)));
240 s++;
241 if (s >= srcend)
242 ereturn(escontext, 0,
243 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
244 errmsg("invalid hexadecimal data: odd number of digits")));
245 if (!get_hex(s, &v2))
246 ereturn(escontext, 0,
247 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
248 errmsg("invalid hexadecimal digit: \"%.*s\"",
249 pg_mblen(s), s)));
250 s++;
251 *p++ = (v1 << 4) | v2;
252 }
253
254 return p - dst;
255}
#define ereturn(context, dummy_value,...)
Definition: elog.h:278
static bool get_hex(const char *cp, char *out)
Definition: encode.c:197
int pg_mblen(const char *mbstr)
Definition: mbutils.c:1023

References ereturn, errcode(), errmsg(), get_hex(), len, and pg_mblen().

Referenced by byteain(), and hex_decode().

◆ hex_enc_len()

static uint64 hex_enc_len ( const char *  src,
size_t  srclen 
)
static

Definition at line 258 of file encode.c.

259{
260 return (uint64) srclen << 1;
261}

◆ hex_encode()

uint64 hex_encode ( const char *  src,
size_t  len,
char *  dst 
)

Definition at line 181 of file encode.c.

182{
183 const char *end = src + len;
184
185 while (src < end)
186 {
187 unsigned char usrc = *((const unsigned char *) src);
188
189 memcpy(dst, &hextbl[2 * usrc], 2);
190 src++;
191 dst += 2;
192 }
193 return (uint64) len * 2;
194}
static const char hextbl[512]
Definition: encode.c:151

References hextbl, and len.

Referenced by AddFileToBackupManifest(), byteaout(), and SendBackupManifest().

◆ pg_base64_dec_len()

static uint64 pg_base64_dec_len ( const char *  src,
size_t  srclen 
)
static

Definition at line 413 of file encode.c.

414{
415 return ((uint64) srclen * 3) >> 2;
416}

◆ pg_base64_decode()

static uint64 pg_base64_decode ( const char *  src,
size_t  len,
char *  dst 
)
static

Definition at line 335 of file encode.c.

336{
337 const char *srcend = src + len,
338 *s = src;
339 char *p = dst;
340 char c;
341 int b = 0;
342 uint32 buf = 0;
343 int pos = 0,
344 end = 0;
345
346 while (s < srcend)
347 {
348 c = *s++;
349
350 if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
351 continue;
352
353 if (c == '=')
354 {
355 /* end sequence */
356 if (!end)
357 {
358 if (pos == 2)
359 end = 1;
360 else if (pos == 3)
361 end = 2;
362 else
364 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
365 errmsg("unexpected \"=\" while decoding base64 sequence")));
366 }
367 b = 0;
368 }
369 else
370 {
371 b = -1;
372 if (c > 0 && c < 127)
373 b = b64lookup[(unsigned char) c];
374 if (b < 0)
376 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
377 errmsg("invalid symbol \"%.*s\" found while decoding base64 sequence",
378 pg_mblen(s - 1), s - 1)));
379 }
380 /* add it to buffer */
381 buf = (buf << 6) + b;
382 pos++;
383 if (pos == 4)
384 {
385 *p++ = (buf >> 16) & 255;
386 if (end == 0 || end > 1)
387 *p++ = (buf >> 8) & 255;
388 if (end == 0 || end > 2)
389 *p++ = buf & 255;
390 buf = 0;
391 pos = 0;
392 }
393 }
394
395 if (pos != 0)
397 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
398 errmsg("invalid base64 end sequence"),
399 errhint("Input data is missing padding, is truncated, or is otherwise corrupted.")));
400
401 return p - dst;
402}
uint32_t uint32
Definition: c.h:502
int errhint(const char *fmt,...)
Definition: elog.c:1318
static const int8 b64lookup[128]
Definition: encode.c:276
int b
Definition: isn.c:74
static char * buf
Definition: pg_test_fsync.c:72

References b, b64lookup, buf, ereport, errcode(), errhint(), errmsg(), ERROR, len, and pg_mblen().

◆ pg_base64_enc_len()

static uint64 pg_base64_enc_len ( const char *  src,
size_t  srclen 
)
static

Definition at line 406 of file encode.c.

407{
408 /* 3 bytes will be converted to 4, linefeed after 76 chars */
409 return ((uint64) srclen + 2) / 3 * 4 + (uint64) srclen / (76 * 3 / 4);
410}

◆ pg_base64_encode()

static uint64 pg_base64_encode ( const char *  src,
size_t  len,
char *  dst 
)
static

Definition at line 288 of file encode.c.

289{
290 char *p,
291 *lend = dst + 76;
292 const char *s,
293 *end = src + len;
294 int pos = 2;
295 uint32 buf = 0;
296
297 s = src;
298 p = dst;
299
300 while (s < end)
301 {
302 buf |= (unsigned char) *s << (pos << 3);
303 pos--;
304 s++;
305
306 /* write it out */
307 if (pos < 0)
308 {
309 *p++ = _base64[(buf >> 18) & 0x3f];
310 *p++ = _base64[(buf >> 12) & 0x3f];
311 *p++ = _base64[(buf >> 6) & 0x3f];
312 *p++ = _base64[buf & 0x3f];
313
314 pos = 2;
315 buf = 0;
316 }
317 if (p >= lend)
318 {
319 *p++ = '\n';
320 lend = p + 76;
321 }
322 }
323 if (pos != 2)
324 {
325 *p++ = _base64[(buf >> 18) & 0x3f];
326 *p++ = _base64[(buf >> 12) & 0x3f];
327 *p++ = (pos == 0) ? _base64[(buf >> 6) & 0x3f] : '=';
328 *p++ = '=';
329 }
330
331 return p - dst;
332}
static const char _base64[]
Definition: encode.c:273

References _base64, buf, and len.

◆ pg_find_encoding()

static const struct pg_encoding * pg_find_encoding ( const char *  name)
static

Definition at line 624 of file encode.c.

625{
626 int i;
627
628 for (i = 0; enclist[i].name; i++)
629 if (pg_strcasecmp(enclist[i].name, name) == 0)
630 return &enclist[i].enc;
631
632 return NULL;
633}
static const struct @22 enclist[]
int i
Definition: isn.c:77
int pg_strcasecmp(const char *s1, const char *s2)
Definition: pgstrcasecmp.c:36

References enclist, i, name, and pg_strcasecmp().

Referenced by binary_decode(), and binary_encode().

Variable Documentation

◆ _base64

const char _base64[]
static
Initial value:
=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"

Definition at line 273 of file encode.c.

Referenced by pg_base64_encode().

◆ b64lookup

const int8 b64lookup[128]
static
Initial value:
= {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
}

Definition at line 276 of file encode.c.

Referenced by pg_base64_decode().

◆ enc

struct pg_encoding enc

Definition at line 593 of file encode.c.

Referenced by binary_decode(), and binary_encode().

◆ 

const struct { ... } enclist[]
Initial value:
=
{
{
"hex",
{
}
},
{
"base64",
{
}
},
{
"escape",
{
}
},
{
NULL,
{
NULL, NULL, NULL, NULL
}
}
}
static uint64 pg_base64_decode(const char *src, size_t len, char *dst)
Definition: encode.c:335
static uint64 hex_dec_len(const char *src, size_t srclen)
Definition: encode.c:264
static uint64 pg_base64_encode(const char *src, size_t len, char *dst)
Definition: encode.c:288
static uint64 esc_encode(const char *src, size_t srclen, char *dst)
Definition: encode.c:436
static uint64 hex_enc_len(const char *src, size_t srclen)
Definition: encode.c:258
uint64 hex_encode(const char *src, size_t len, char *dst)
Definition: encode.c:181
static uint64 esc_enc_len(const char *src, size_t srclen)
Definition: encode.c:523
static uint64 pg_base64_enc_len(const char *src, size_t srclen)
Definition: encode.c:406
static uint64 esc_decode(const char *src, size_t srclen, char *dst)
Definition: encode.c:475
static uint64 esc_dec_len(const char *src, size_t srclen)
Definition: encode.c:544
uint64 hex_decode(const char *src, size_t len, char *dst)
Definition: encode.c:211
static uint64 pg_base64_dec_len(const char *src, size_t srclen)
Definition: encode.c:413

Referenced by pg_find_encoding().

◆ hexlookup

const int8 hexlookup[128]
static
Initial value:
= {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
}

Definition at line 169 of file encode.c.

Referenced by get_hex().

◆ hextbl

const char hextbl[512]
static
Initial value:
=
"000102030405060708090a0b0c0d0e0f"
"101112131415161718191a1b1c1d1e1f"
"202122232425262728292a2b2c2d2e2f"
"303132333435363738393a3b3c3d3e3f"
"404142434445464748494a4b4c4d4e4f"
"505152535455565758595a5b5c5d5e5f"
"606162636465666768696a6b6c6d6e6f"
"707172737475767778797a7b7c7d7e7f"
"808182838485868788898a8b8c8d8e8f"
"909192939495969798999a9b9c9d9e9f"
"a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
"b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
"c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
"d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
"e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
"f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"

Definition at line 151 of file encode.c.

Referenced by hex_encode().

◆ name

const char* name

Definition at line 592 of file encode.c.

Referenced by binary_decode(), binary_encode(), and pg_find_encoding().