2fe8fb192f
There is important information about booting non-ack images in docs/UPDATING. ack/aout-format images can't be built any more, and booting clang/ELF-format ones is a little different. Updating to the new boot monitor is recommended. Changes in this commit: . drop boot monitor -> allowing dropping ack support . facility to copy ELF boot files to /boot so that old boot monitor can still boot fairly easily, see UPDATING . no more ack-format libraries -> single-case libraries . some cleanup of OBJECT_FMT, COMPILER_TYPE, etc cases . drop several ack toolchain commands, but not all support commands (e.g. aal is gone but acksize is not yet). . a few libc files moved to netbsd libc dir . new /bin/date as minix date used code in libc/ . test compile fix . harmonize includes . /usr/lib is no longer special: without ack, /usr/lib plays no kind of special bootstrapping role any more and bootstrapping is done exclusively through packages, so releases depend even less on the state of the machine making them now. . rename nbsd_lib* to lib* . reduce mtree
1348 lines
30 KiB
C
1348 lines
30 KiB
C
/* $NetBSD: citrus_iso2022.c,v 1.20 2010/12/07 22:01:45 joerg Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c)1999, 2002 Citrus Project,
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $Citrus: xpg4dl/FreeBSD/lib/libc/locale/iso2022.c,v 1.23 2001/06/21 01:51:44 yamt Exp $
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#if defined(LIBC_SCCS) && !defined(lint)
|
|
__RCSID("$NetBSD: citrus_iso2022.c,v 1.20 2010/12/07 22:01:45 joerg Exp $");
|
|
#endif /* LIBC_SCCS and not lint */
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <stddef.h>
|
|
#include <wchar.h>
|
|
#include <sys/types.h>
|
|
#include <limits.h>
|
|
|
|
#include "citrus_namespace.h"
|
|
#include "citrus_types.h"
|
|
#include "citrus_module.h"
|
|
#include "citrus_ctype.h"
|
|
#include "citrus_stdenc.h"
|
|
#include "citrus_iso2022.h"
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* private stuffs used by templates
|
|
*/
|
|
|
|
|
|
/*
|
|
* wchar_t mappings:
|
|
* ASCII (ESC ( B) 00000000 00000000 00000000 0xxxxxxx
|
|
* iso-8859-1 (ESC , A) 00000000 00000000 00000000 1xxxxxxx
|
|
* 94 charset (ESC ( F) 0fffffff 00000000 00000000 0xxxxxxx
|
|
* 94 charset (ESC ( M F) 0fffffff 1mmmmmmm 00000000 0xxxxxxx
|
|
* 96 charset (ESC , F) 0fffffff 00000000 00000000 1xxxxxxx
|
|
* 96 charset (ESC , M F) 0fffffff 1mmmmmmm 00000000 1xxxxxxx
|
|
* 94x94 charset (ESC $ ( F) 0fffffff 00000000 0xxxxxxx 0xxxxxxx
|
|
* 96x96 charset (ESC $ , F) 0fffffff 00000000 0xxxxxxx 1xxxxxxx
|
|
* 94x94 charset (ESC & V ESC $ ( F)
|
|
* 0fffffff 1vvvvvvv 0xxxxxxx 0xxxxxxx
|
|
* 94x94x94 charset (ESC $ ( F) 0fffffff 0xxxxxxx 0xxxxxxx 0xxxxxxx
|
|
* 96x96x96 charset (ESC $ , F) 0fffffff 0xxxxxxx 0xxxxxxx 1xxxxxxx
|
|
* reserved for UCS4 co-existence (UCS4 is 31bit encoding thanks to mohta bit)
|
|
* 1xxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
|
|
*/
|
|
|
|
typedef struct {
|
|
u_char type;
|
|
#define CS94 (0U)
|
|
#define CS96 (1U)
|
|
#define CS94MULTI (2U)
|
|
#define CS96MULTI (3U)
|
|
|
|
u_char final;
|
|
u_char interm;
|
|
u_char vers;
|
|
} _ISO2022Charset;
|
|
|
|
static const _ISO2022Charset ascii = { CS94, 'B', '\0', '\0' };
|
|
static const _ISO2022Charset iso88591 = { CS96, 'A', '\0', '\0' };
|
|
|
|
typedef struct {
|
|
_ISO2022Charset g[4];
|
|
/* need 3 bits to hold -1, 0, ..., 3 */
|
|
int gl:3,
|
|
gr:3,
|
|
singlegl:3,
|
|
singlegr:3;
|
|
char ch[7]; /* longest escape sequence (ESC & V ESC $ ( F) */
|
|
int chlen;
|
|
int flags;
|
|
#define _ISO2022STATE_FLAG_INITIALIZED 1
|
|
} _ISO2022State;
|
|
|
|
typedef struct {
|
|
_ISO2022Charset *recommend[4];
|
|
size_t recommendsize[4];
|
|
_ISO2022Charset initg[4];
|
|
int maxcharset;
|
|
int flags;
|
|
#define F_8BIT 0x0001
|
|
#define F_NOOLD 0x0002
|
|
#define F_SI 0x0010 /*0F*/
|
|
#define F_SO 0x0020 /*0E*/
|
|
#define F_LS0 0x0010 /*0F*/
|
|
#define F_LS1 0x0020 /*0E*/
|
|
#define F_LS2 0x0040 /*ESC n*/
|
|
#define F_LS3 0x0080 /*ESC o*/
|
|
#define F_LS1R 0x0100 /*ESC ~*/
|
|
#define F_LS2R 0x0200 /*ESC }*/
|
|
#define F_LS3R 0x0400 /*ESC |*/
|
|
#define F_SS2 0x0800 /*ESC N*/
|
|
#define F_SS3 0x1000 /*ESC O*/
|
|
#define F_SS2R 0x2000 /*8E*/
|
|
#define F_SS3R 0x4000 /*8F*/
|
|
} _ISO2022EncodingInfo;
|
|
typedef struct {
|
|
_ISO2022EncodingInfo ei;
|
|
struct {
|
|
/* for future multi-locale facility */
|
|
_ISO2022State s_mblen;
|
|
_ISO2022State s_mbrlen;
|
|
_ISO2022State s_mbrtowc;
|
|
_ISO2022State s_mbtowc;
|
|
_ISO2022State s_mbsrtowcs;
|
|
_ISO2022State s_wcrtomb;
|
|
_ISO2022State s_wcsrtombs;
|
|
_ISO2022State s_wctomb;
|
|
} states;
|
|
} _ISO2022CTypeInfo;
|
|
|
|
#define _CEI_TO_EI(_cei_) (&(_cei_)->ei)
|
|
#define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
|
|
|
|
#define _FUNCNAME(m) _citrus_ISO2022_##m
|
|
#define _ENCODING_INFO _ISO2022EncodingInfo
|
|
#define _CTYPE_INFO _ISO2022CTypeInfo
|
|
#define _ENCODING_STATE _ISO2022State
|
|
#define _ENCODING_MB_CUR_MAX(_ei_) MB_LEN_MAX
|
|
#define _ENCODING_IS_STATE_DEPENDENT 1
|
|
#define _STATE_NEEDS_EXPLICIT_INIT(_ps_) \
|
|
(!((_ps_)->flags & _ISO2022STATE_FLAG_INITIALIZED))
|
|
|
|
|
|
#define _ISO2022INVALID (wchar_t)-1
|
|
|
|
static __inline int isc0(__uint8_t x) { return ((x & 0x1f) == x); }
|
|
static __inline int isc1(__uint8_t x) { return (0x80 <= x && x <= 0x9f); }
|
|
static __inline int iscntl(__uint8_t x) { return (isc0(x) || isc1(x) || x == 0x7f); }
|
|
static __inline int is94(__uint8_t x) { return (0x21 <= x && x <= 0x7e); }
|
|
static __inline int is96(__uint8_t x) { return (0x20 <= x && x <= 0x7f); }
|
|
static __inline int isecma(__uint8_t x) { return (0x30 <= x && x <= 0x7f); }
|
|
static __inline int isinterm(__uint8_t x) { return (0x20 <= x && x <= 0x2f); }
|
|
static __inline int isthree(__uint8_t x) { return (0x60 <= x && x <= 0x6f); }
|
|
|
|
static __inline int
|
|
getcs(const char * __restrict p, _ISO2022Charset * __restrict cs)
|
|
{
|
|
|
|
_DIAGASSERT(p != NULL);
|
|
_DIAGASSERT(cs != NULL);
|
|
|
|
if (!strncmp(p, "94$", 3) && p[3] && !p[4]) {
|
|
cs->final = (u_char)(p[3] & 0xff);
|
|
cs->interm = '\0';
|
|
cs->vers = '\0';
|
|
cs->type = CS94MULTI;
|
|
} else if (!strncmp(p, "96$", 3) && p[3] && !p[4]) {
|
|
cs->final = (u_char)(p[3] & 0xff);
|
|
cs->interm = '\0';
|
|
cs->vers = '\0';
|
|
cs->type = CS96MULTI;
|
|
} else if (!strncmp(p, "94", 2) && p[2] && !p[3]) {
|
|
cs->final = (u_char)(p[2] & 0xff);
|
|
cs->interm = '\0';
|
|
cs->vers = '\0';
|
|
cs->type = CS94;
|
|
} else if (!strncmp(p, "96", 2) && p[2] && !p[3]) {
|
|
cs->final = (u_char )(p[2] & 0xff);
|
|
cs->interm = '\0';
|
|
cs->vers = '\0';
|
|
cs->type = CS96;
|
|
} else {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
#define _NOTMATCH 0
|
|
#define _MATCH 1
|
|
#define _PARSEFAIL 2
|
|
|
|
static __inline int
|
|
get_recommend(_ISO2022EncodingInfo * __restrict ei,
|
|
const char * __restrict token)
|
|
{
|
|
int i;
|
|
_ISO2022Charset cs, *p;
|
|
|
|
if (!strchr("0123", token[0]) || token[1] != '=')
|
|
return (_NOTMATCH);
|
|
|
|
if (getcs(&token[2], &cs) == 0)
|
|
;
|
|
else if (!strcmp(&token[2], "94")) {
|
|
cs.final = (u_char)(token[4]);
|
|
cs.interm = '\0';
|
|
cs.vers = '\0';
|
|
cs.type = CS94;
|
|
} else if (!strcmp(&token[2], "96")) {
|
|
cs.final = (u_char)(token[4]);
|
|
cs.interm = '\0';
|
|
cs.vers = '\0';
|
|
cs.type = CS96;
|
|
} else if (!strcmp(&token[2], "94$")) {
|
|
cs.final = (u_char)(token[5]);
|
|
cs.interm = '\0';
|
|
cs.vers = '\0';
|
|
cs.type = CS94MULTI;
|
|
} else if (!strcmp(&token[2], "96$")) {
|
|
cs.final = (u_char)(token[5]);
|
|
cs.interm = '\0';
|
|
cs.vers = '\0';
|
|
cs.type = CS96MULTI;
|
|
} else {
|
|
return (_PARSEFAIL);
|
|
}
|
|
|
|
i = token[0] - '0';
|
|
if (!ei->recommend[i]) {
|
|
ei->recommend[i] = malloc(sizeof(_ISO2022Charset));
|
|
} else {
|
|
p = realloc(ei->recommend[i],
|
|
sizeof(_ISO2022Charset) * (ei->recommendsize[i] + 1));
|
|
if (!p)
|
|
return (_PARSEFAIL);
|
|
ei->recommend[i] = p;
|
|
}
|
|
if (!ei->recommend[i])
|
|
return (_PARSEFAIL);
|
|
ei->recommendsize[i]++;
|
|
|
|
(ei->recommend[i] + (ei->recommendsize[i] - 1))->final = cs.final;
|
|
(ei->recommend[i] + (ei->recommendsize[i] - 1))->interm = cs.interm;
|
|
(ei->recommend[i] + (ei->recommendsize[i] - 1))->vers = cs.vers;
|
|
(ei->recommend[i] + (ei->recommendsize[i] - 1))->type = cs.type;
|
|
|
|
return (_MATCH);
|
|
}
|
|
|
|
static __inline int
|
|
get_initg(_ISO2022EncodingInfo * __restrict ei,
|
|
const char * __restrict token)
|
|
{
|
|
_ISO2022Charset cs;
|
|
|
|
if (strncmp("INIT", &token[0], 4) ||
|
|
!strchr("0123", token[4]) ||
|
|
token[5] != '=')
|
|
return (_NOTMATCH);
|
|
|
|
if (getcs(&token[6], &cs) != 0)
|
|
return (_PARSEFAIL);
|
|
|
|
ei->initg[token[4] - '0'].type = cs.type;
|
|
ei->initg[token[4] - '0'].final = cs.final;
|
|
ei->initg[token[4] - '0'].interm = cs.interm;
|
|
ei->initg[token[4] - '0'].vers = cs.vers;
|
|
|
|
return (_MATCH);
|
|
}
|
|
|
|
static __inline int
|
|
get_max(_ISO2022EncodingInfo * __restrict ei,
|
|
const char * __restrict token)
|
|
{
|
|
if (!strcmp(token, "MAX1")) {
|
|
ei->maxcharset = 1;
|
|
} else if (!strcmp(token, "MAX2")) {
|
|
ei->maxcharset = 2;
|
|
} else if (!strcmp(token, "MAX3")) {
|
|
ei->maxcharset = 3;
|
|
} else
|
|
return (_NOTMATCH);
|
|
|
|
return (_MATCH);
|
|
}
|
|
|
|
|
|
static __inline int
|
|
get_flags(_ISO2022EncodingInfo * __restrict ei,
|
|
const char * __restrict token)
|
|
{
|
|
int i;
|
|
static struct {
|
|
const char *tag;
|
|
int flag;
|
|
} const tags[] = {
|
|
{ "DUMMY", 0 },
|
|
{ "8BIT", F_8BIT },
|
|
{ "NOOLD", F_NOOLD },
|
|
{ "SI", F_SI },
|
|
{ "SO", F_SO },
|
|
{ "LS0", F_LS0 },
|
|
{ "LS1", F_LS1 },
|
|
{ "LS2", F_LS2 },
|
|
{ "LS3", F_LS3 },
|
|
{ "LS1R", F_LS1R },
|
|
{ "LS2R", F_LS2R },
|
|
{ "LS3R", F_LS3R },
|
|
{ "SS2", F_SS2 },
|
|
{ "SS3", F_SS3 },
|
|
{ "SS2R", F_SS2R },
|
|
{ "SS3R", F_SS3R },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
for (i = 0; tags[i].tag; i++) {
|
|
if (!strcmp(token, tags[i].tag)) {
|
|
ei->flags |= tags[i].flag;
|
|
return (_MATCH);
|
|
}
|
|
}
|
|
|
|
return (_NOTMATCH);
|
|
}
|
|
|
|
|
|
static __inline int
|
|
_citrus_ISO2022_parse_variable(_ISO2022EncodingInfo * __restrict ei,
|
|
const void * __restrict var, size_t lenvar)
|
|
{
|
|
char const *v, *e;
|
|
char buf[20];
|
|
int i, len, ret;
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
|
|
|
|
/*
|
|
* parse VARIABLE section.
|
|
*/
|
|
|
|
if (!var)
|
|
return (EFTYPE);
|
|
|
|
v = (const char *) var;
|
|
|
|
/* initialize structure */
|
|
ei->maxcharset = 0;
|
|
for (i = 0; i < 4; i++) {
|
|
ei->recommend[i] = NULL;
|
|
ei->recommendsize[i] = 0;
|
|
}
|
|
ei->flags = 0;
|
|
|
|
while (*v) {
|
|
while (*v == ' ' || *v == '\t')
|
|
++v;
|
|
|
|
/* find the token */
|
|
e = v;
|
|
while (*e && *e != ' ' && *e != '\t')
|
|
++e;
|
|
|
|
len = e-v;
|
|
if (len == 0)
|
|
break;
|
|
if (len>=sizeof(buf))
|
|
goto parsefail;
|
|
snprintf(buf, sizeof(buf), "%.*s", len, v);
|
|
|
|
if ((ret = get_recommend(ei, buf)) != _NOTMATCH)
|
|
;
|
|
else if ((ret = get_initg(ei, buf)) != _NOTMATCH)
|
|
;
|
|
else if ((ret = get_max(ei, buf)) != _NOTMATCH)
|
|
;
|
|
else if ((ret = get_flags(ei, buf)) != _NOTMATCH)
|
|
;
|
|
else
|
|
ret = _PARSEFAIL;
|
|
if (ret==_PARSEFAIL)
|
|
goto parsefail;
|
|
v = e;
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
parsefail:
|
|
free(ei->recommend[0]);
|
|
free(ei->recommend[1]);
|
|
free(ei->recommend[2]);
|
|
free(ei->recommend[3]);
|
|
|
|
return (EFTYPE);
|
|
}
|
|
|
|
static __inline void
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_init_state(_ISO2022EncodingInfo * __restrict ei,
|
|
_ISO2022State * __restrict s)
|
|
{
|
|
int i;
|
|
|
|
memset(s, 0, sizeof(*s));
|
|
s->gl = 0;
|
|
s->gr = (ei->flags & F_8BIT) ? 1 : -1;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
if (ei->initg[i].final) {
|
|
s->g[i].type = ei->initg[i].type;
|
|
s->g[i].final = ei->initg[i].final;
|
|
s->g[i].interm = ei->initg[i].interm;
|
|
}
|
|
}
|
|
s->singlegl = s->singlegr = -1;
|
|
s->flags |= _ISO2022STATE_FLAG_INITIALIZED;
|
|
}
|
|
|
|
static __inline void
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_pack_state(_ISO2022EncodingInfo * __restrict ei,
|
|
void * __restrict pspriv,
|
|
const _ISO2022State * __restrict s)
|
|
{
|
|
memcpy(pspriv, (const void *)s, sizeof(*s));
|
|
}
|
|
|
|
static __inline void
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_unpack_state(_ISO2022EncodingInfo * __restrict ei,
|
|
_ISO2022State * __restrict s,
|
|
const void * __restrict pspriv)
|
|
{
|
|
memcpy((void *)s, pspriv, sizeof(*s));
|
|
}
|
|
|
|
static int
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_encoding_module_init(_ISO2022EncodingInfo * __restrict ei,
|
|
const void * __restrict var,
|
|
size_t lenvar)
|
|
{
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
|
|
return _citrus_ISO2022_parse_variable(ei, var, lenvar);
|
|
}
|
|
|
|
static void
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_encoding_module_uninit(_ISO2022EncodingInfo *ei)
|
|
{
|
|
}
|
|
|
|
#define ESC '\033'
|
|
#define ECMA -1
|
|
#define INTERM -2
|
|
#define OECMA -3
|
|
static const struct seqtable {
|
|
int type;
|
|
int csoff;
|
|
int finaloff;
|
|
int intermoff;
|
|
int versoff;
|
|
int len;
|
|
int chars[10];
|
|
} seqtable[] = {
|
|
/* G0 94MULTI special */
|
|
{ CS94MULTI, -1, 2, -1, -1, 3, { ESC, '$', OECMA }, },
|
|
/* G0 94MULTI special with version identification */
|
|
{ CS94MULTI, -1, 5, -1, 2, 6, { ESC, '&', ECMA, ESC, '$', OECMA }, },
|
|
/* G? 94 */
|
|
{ CS94, 1, 2, -1, -1, 3, { ESC, CS94, ECMA, }, },
|
|
/* G? 94 with 2nd intermediate char */
|
|
{ CS94, 1, 3, 2, -1, 4, { ESC, CS94, INTERM, ECMA, }, },
|
|
/* G? 96 */
|
|
{ CS96, 1, 2, -1, -1, 3, { ESC, CS96, ECMA, }, },
|
|
/* G? 96 with 2nd intermediate char */
|
|
{ CS96, 1, 3, 2, -1, 4, { ESC, CS96, INTERM, ECMA, }, },
|
|
/* G? 94MULTI */
|
|
{ CS94MULTI, 2, 3, -1, -1, 4, { ESC, '$', CS94, ECMA, }, },
|
|
/* G? 96MULTI */
|
|
{ CS96MULTI, 2, 3, -1, -1, 4, { ESC, '$', CS96, ECMA, }, },
|
|
/* G? 94MULTI with version specification */
|
|
{ CS94MULTI, 5, 6, -1, 2, 7, { ESC, '&', ECMA, ESC, '$', CS94, ECMA, }, },
|
|
/* LS2/3 */
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, 'n', }, },
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, 'o', }, },
|
|
/* LS1/2/3R */
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, '~', }, },
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, /*{*/ '}', }, },
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, '|', }, },
|
|
/* SS2/3 */
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, 'N', }, },
|
|
{ -1, -1, -1, -1, -1, 2, { ESC, 'O', }, },
|
|
/* end of records */
|
|
{ 0, }
|
|
};
|
|
|
|
static int
|
|
seqmatch(const char * __restrict s, size_t n,
|
|
const struct seqtable * __restrict sp)
|
|
{
|
|
const int *p;
|
|
|
|
_DIAGASSERT(s != NULL);
|
|
_DIAGASSERT(sp != NULL);
|
|
|
|
p = sp->chars;
|
|
while (p - sp->chars < n && p - sp->chars < sp->len) {
|
|
switch (*p) {
|
|
case ECMA:
|
|
if (!isecma(*s))
|
|
goto terminate;
|
|
break;
|
|
case OECMA:
|
|
if (*s && strchr("@AB", *s))
|
|
break;
|
|
else
|
|
goto terminate;
|
|
case INTERM:
|
|
if (!isinterm(*s))
|
|
goto terminate;
|
|
break;
|
|
case CS94:
|
|
if (*s && strchr("()*+", *s))
|
|
break;
|
|
else
|
|
goto terminate;
|
|
case CS96:
|
|
if (*s && strchr(",-./", *s))
|
|
break;
|
|
else
|
|
goto terminate;
|
|
default:
|
|
if (*s != *p)
|
|
goto terminate;
|
|
break;
|
|
}
|
|
|
|
p++;
|
|
s++;
|
|
}
|
|
|
|
terminate:
|
|
return p - sp->chars;
|
|
}
|
|
|
|
static wchar_t
|
|
_ISO2022_sgetwchar(_ISO2022EncodingInfo * __restrict ei,
|
|
const char * __restrict string, size_t n,
|
|
const char ** __restrict result,
|
|
_ISO2022State * __restrict psenc)
|
|
{
|
|
wchar_t wchar = 0;
|
|
int cur;
|
|
const struct seqtable *sp;
|
|
int nmatch;
|
|
int i;
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
_DIAGASSERT(psenc != NULL);
|
|
_DIAGASSERT(string != NULL);
|
|
/* result may be NULL */
|
|
|
|
while (1) {
|
|
/* SI/SO */
|
|
if (1 <= n && string[0] == '\017') {
|
|
psenc->gl = 0;
|
|
string++;
|
|
n--;
|
|
continue;
|
|
}
|
|
if (1 <= n && string[0] == '\016') {
|
|
psenc->gl = 1;
|
|
string++;
|
|
n--;
|
|
continue;
|
|
}
|
|
|
|
/* SS2/3R */
|
|
if (1 <= n && string[0] && strchr("\217\216", string[0])) {
|
|
psenc->singlegl = psenc->singlegr =
|
|
(string[0] - '\216') + 2;
|
|
string++;
|
|
n--;
|
|
continue;
|
|
}
|
|
|
|
/* eat the letter if this is not ESC */
|
|
if (1 <= n && string[0] != '\033')
|
|
break;
|
|
|
|
/* look for a perfect match from escape sequences */
|
|
for (sp = &seqtable[0]; sp->len; sp++) {
|
|
nmatch = seqmatch(string, n, sp);
|
|
if (sp->len == nmatch && n >= sp->len)
|
|
break;
|
|
}
|
|
|
|
if (!sp->len)
|
|
goto notseq;
|
|
|
|
if (sp->type != -1) {
|
|
if (sp->csoff == -1)
|
|
i = 0;
|
|
else {
|
|
switch (sp->type) {
|
|
case CS94:
|
|
case CS94MULTI:
|
|
i = string[sp->csoff] - '(';
|
|
break;
|
|
case CS96:
|
|
case CS96MULTI:
|
|
i = string[sp->csoff] - ',';
|
|
break;
|
|
default:
|
|
return (_ISO2022INVALID);
|
|
}
|
|
}
|
|
psenc->g[i].type = sp->type;
|
|
psenc->g[i].final = '\0';
|
|
psenc->g[i].interm = '\0';
|
|
psenc->g[i].vers = '\0';
|
|
/* sp->finaloff must not be -1 */
|
|
if (sp->finaloff != -1)
|
|
psenc->g[i].final = string[sp->finaloff];
|
|
if (sp->intermoff != -1)
|
|
psenc->g[i].interm = string[sp->intermoff];
|
|
if (sp->versoff != -1)
|
|
psenc->g[i].vers = string[sp->versoff];
|
|
|
|
string += sp->len;
|
|
n -= sp->len;
|
|
continue;
|
|
}
|
|
|
|
/* LS2/3 */
|
|
if (2 <= n && string[0] == '\033'
|
|
&& string[1] && strchr("no", string[1])) {
|
|
psenc->gl = string[1] - 'n' + 2;
|
|
string += 2;
|
|
n -= 2;
|
|
continue;
|
|
}
|
|
|
|
/* LS1/2/3R */
|
|
/* XXX: { for vi showmatch */
|
|
if (2 <= n && string[0] == '\033'
|
|
&& string[1] && strchr("~}|", string[1])) {
|
|
psenc->gr = 3 - (string[1] - '|');
|
|
string += 2;
|
|
n -= 2;
|
|
continue;
|
|
}
|
|
|
|
/* SS2/3 */
|
|
if (2 <= n && string[0] == '\033'
|
|
&& string[1] && strchr("NO", string[1])) {
|
|
psenc->singlegl = (string[1] - 'N') + 2;
|
|
string += 2;
|
|
n -= 2;
|
|
continue;
|
|
}
|
|
|
|
notseq:
|
|
/*
|
|
* if we've got an unknown escape sequence, eat the ESC at the
|
|
* head. otherwise, wait till full escape sequence comes.
|
|
*/
|
|
for (sp = &seqtable[0]; sp->len; sp++) {
|
|
nmatch = seqmatch(string, n, sp);
|
|
if (!nmatch)
|
|
continue;
|
|
|
|
/*
|
|
* if we are in the middle of escape sequence,
|
|
* we still need to wait for more characters to come
|
|
*/
|
|
if (n < sp->len) {
|
|
if (nmatch == n) {
|
|
if (result)
|
|
*result = string;
|
|
return (_ISO2022INVALID);
|
|
}
|
|
} else {
|
|
if (nmatch == sp->len) {
|
|
/* this case should not happen */
|
|
goto eat;
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
eat:
|
|
/* no letter to eat */
|
|
if (n < 1) {
|
|
if (result)
|
|
*result = string;
|
|
return (_ISO2022INVALID);
|
|
}
|
|
|
|
/* normal chars. always eat C0/C1 as is. */
|
|
if (iscntl(*string & 0xff))
|
|
cur = -1;
|
|
else if (*string & 0x80) {
|
|
cur = (psenc->singlegr == -1)
|
|
? psenc->gr : psenc->singlegr;
|
|
} else {
|
|
cur = (psenc->singlegl == -1)
|
|
? psenc->gl : psenc->singlegl;
|
|
}
|
|
|
|
if (cur == -1) {
|
|
asis:
|
|
wchar = *string++ & 0xff;
|
|
if (result)
|
|
*result = string;
|
|
/* reset single shift state */
|
|
psenc->singlegr = psenc->singlegl = -1;
|
|
return wchar;
|
|
}
|
|
|
|
/* length error check */
|
|
switch (psenc->g[cur].type) {
|
|
case CS94MULTI:
|
|
case CS96MULTI:
|
|
if (!isthree(psenc->g[cur].final)) {
|
|
if (2 <= n
|
|
&& (string[0] & 0x80) == (string[1] & 0x80))
|
|
break;
|
|
} else {
|
|
if (3 <= n
|
|
&& (string[0] & 0x80) == (string[1] & 0x80)
|
|
&& (string[0] & 0x80) == (string[2] & 0x80))
|
|
break;
|
|
}
|
|
|
|
/* we still need to wait for more characters to come */
|
|
if (result)
|
|
*result = string;
|
|
return (_ISO2022INVALID);
|
|
|
|
case CS94:
|
|
case CS96:
|
|
if (1 <= n)
|
|
break;
|
|
|
|
/* we still need to wait for more characters to come */
|
|
if (result)
|
|
*result = string;
|
|
return (_ISO2022INVALID);
|
|
}
|
|
|
|
/* range check */
|
|
switch (psenc->g[cur].type) {
|
|
case CS94:
|
|
if (!(is94(string[0] & 0x7f)))
|
|
goto asis;
|
|
case CS96:
|
|
if (!(is96(string[0] & 0x7f)))
|
|
goto asis;
|
|
break;
|
|
case CS94MULTI:
|
|
if (!(is94(string[0] & 0x7f) && is94(string[1] & 0x7f)))
|
|
goto asis;
|
|
break;
|
|
case CS96MULTI:
|
|
if (!(is96(string[0] & 0x7f) && is96(string[1] & 0x7f)))
|
|
goto asis;
|
|
break;
|
|
}
|
|
|
|
/* extract the character. */
|
|
switch (psenc->g[cur].type) {
|
|
case CS94:
|
|
/* special case for ASCII. */
|
|
if (psenc->g[cur].final == 'B' && !psenc->g[cur].interm) {
|
|
wchar = *string++;
|
|
wchar &= 0x7f;
|
|
break;
|
|
}
|
|
wchar = psenc->g[cur].final;
|
|
wchar = (wchar << 8);
|
|
wchar |= (psenc->g[cur].interm ? (0x80 | psenc->g[cur].interm) : 0);
|
|
wchar = (wchar << 8);
|
|
wchar = (wchar << 8) | (*string++ & 0x7f);
|
|
break;
|
|
case CS96:
|
|
/* special case for ISO-8859-1. */
|
|
if (psenc->g[cur].final == 'A' && !psenc->g[cur].interm) {
|
|
wchar = *string++;
|
|
wchar &= 0x7f;
|
|
wchar |= 0x80;
|
|
break;
|
|
}
|
|
wchar = psenc->g[cur].final;
|
|
wchar = (wchar << 8);
|
|
wchar |= (psenc->g[cur].interm ? (0x80 | psenc->g[cur].interm) : 0);
|
|
wchar = (wchar << 8);
|
|
wchar = (wchar << 8) | (*string++ & 0x7f);
|
|
wchar |= 0x80;
|
|
break;
|
|
case CS94MULTI:
|
|
case CS96MULTI:
|
|
wchar = psenc->g[cur].final;
|
|
wchar = (wchar << 8);
|
|
if (isthree(psenc->g[cur].final))
|
|
wchar |= (*string++ & 0x7f);
|
|
wchar = (wchar << 8) | (*string++ & 0x7f);
|
|
wchar = (wchar << 8) | (*string++ & 0x7f);
|
|
if (psenc->g[cur].type == CS96MULTI)
|
|
wchar |= 0x80;
|
|
break;
|
|
}
|
|
|
|
if (result)
|
|
*result = string;
|
|
/* reset single shift state */
|
|
psenc->singlegr = psenc->singlegl = -1;
|
|
return wchar;
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
_citrus_ISO2022_mbrtowc_priv(_ISO2022EncodingInfo * __restrict ei,
|
|
wchar_t * __restrict pwc,
|
|
const char ** __restrict s,
|
|
size_t n, _ISO2022State * __restrict psenc,
|
|
size_t * __restrict nresult)
|
|
{
|
|
wchar_t wchar;
|
|
const char *s0, *p, *result;
|
|
int c;
|
|
int chlenbak;
|
|
|
|
_DIAGASSERT(nresult != 0);
|
|
_DIAGASSERT(ei != NULL);
|
|
_DIAGASSERT(psenc != NULL);
|
|
_DIAGASSERT(s != NULL);
|
|
|
|
if (*s == NULL) {
|
|
_citrus_ISO2022_init_state(ei, psenc);
|
|
*nresult = _ENCODING_IS_STATE_DEPENDENT;
|
|
return 0;
|
|
}
|
|
s0 = *s;
|
|
c = 0;
|
|
chlenbak = psenc->chlen;
|
|
|
|
/*
|
|
* if we have something in buffer, use that.
|
|
* otherwise, skip here
|
|
*/
|
|
if (psenc->chlen < 0 || psenc->chlen > sizeof(psenc->ch)) {
|
|
/* illgeal state */
|
|
_citrus_ISO2022_init_state(ei, psenc);
|
|
goto encoding_error;
|
|
}
|
|
if (psenc->chlen == 0)
|
|
goto emptybuf;
|
|
|
|
/* buffer is not empty */
|
|
p = psenc->ch;
|
|
while (psenc->chlen < sizeof(psenc->ch)) {
|
|
if (n > 0) {
|
|
psenc->ch[psenc->chlen++] = *s0++;
|
|
n--;
|
|
}
|
|
|
|
wchar = _ISO2022_sgetwchar(ei, p, psenc->chlen - (p-psenc->ch),
|
|
&result, psenc);
|
|
c += result - p;
|
|
if (wchar != _ISO2022INVALID) {
|
|
if (psenc->chlen > c)
|
|
memmove(psenc->ch, result, psenc->chlen - c);
|
|
if (psenc->chlen < c)
|
|
psenc->chlen = 0;
|
|
else
|
|
psenc->chlen -= c;
|
|
goto output;
|
|
}
|
|
|
|
if (n == 0) {
|
|
if ((result - p) == psenc->chlen)
|
|
/* complete shift sequence. */
|
|
psenc->chlen = 0;
|
|
goto restart;
|
|
}
|
|
|
|
p = result;
|
|
}
|
|
|
|
/* escape sequence too long? */
|
|
goto encoding_error;
|
|
|
|
emptybuf:
|
|
wchar = _ISO2022_sgetwchar(ei, s0, n, &result, psenc);
|
|
if (wchar != _ISO2022INVALID) {
|
|
c += result - s0;
|
|
psenc->chlen = 0;
|
|
s0 = result;
|
|
goto output;
|
|
}
|
|
if (result > s0) {
|
|
c += (result - s0);
|
|
n -= (result - s0);
|
|
s0 = result;
|
|
if (n>0)
|
|
goto emptybuf;
|
|
/* complete shift sequence. */
|
|
goto restart;
|
|
}
|
|
n += c;
|
|
if (n < sizeof(psenc->ch)) {
|
|
memcpy(psenc->ch, s0 - c, n);
|
|
psenc->chlen = n;
|
|
s0 = result;
|
|
goto restart;
|
|
}
|
|
|
|
/* escape sequence too long? */
|
|
|
|
encoding_error:
|
|
psenc->chlen = 0;
|
|
*nresult = (size_t)-1;
|
|
return (EILSEQ);
|
|
|
|
output:
|
|
*s = s0;
|
|
if (pwc)
|
|
*pwc = wchar;
|
|
|
|
if (!wchar)
|
|
*nresult = 0;
|
|
else
|
|
*nresult = c - chlenbak;
|
|
|
|
return (0);
|
|
|
|
restart:
|
|
*s = s0;
|
|
*nresult = (size_t)-2;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
recommendation(_ISO2022EncodingInfo * __restrict ei,
|
|
_ISO2022Charset * __restrict cs)
|
|
{
|
|
int i, j;
|
|
_ISO2022Charset *recommend;
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
_DIAGASSERT(cs != NULL);
|
|
|
|
/* first, try a exact match. */
|
|
for (i = 0; i < 4; i++) {
|
|
recommend = ei->recommend[i];
|
|
for (j = 0; j < ei->recommendsize[i]; j++) {
|
|
if (cs->type != recommend[j].type)
|
|
continue;
|
|
if (cs->final != recommend[j].final)
|
|
continue;
|
|
if (cs->interm != recommend[j].interm)
|
|
continue;
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
/* then, try a wildcard match over final char. */
|
|
for (i = 0; i < 4; i++) {
|
|
recommend = ei->recommend[i];
|
|
for (j = 0; j < ei->recommendsize[i]; j++) {
|
|
if (cs->type != recommend[j].type)
|
|
continue;
|
|
if (cs->final && (cs->final != recommend[j].final))
|
|
continue;
|
|
if (cs->interm && (cs->interm != recommend[j].interm))
|
|
continue;
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
/* there's no recommendation. make a guess. */
|
|
if (ei->maxcharset == 0) {
|
|
return 0;
|
|
} else {
|
|
switch (cs->type) {
|
|
case CS94:
|
|
case CS94MULTI:
|
|
return 0;
|
|
case CS96:
|
|
case CS96MULTI:
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
_ISO2022_sputwchar(_ISO2022EncodingInfo * __restrict ei, wchar_t wc,
|
|
char * __restrict string, size_t n,
|
|
char ** __restrict result,
|
|
_ISO2022State * __restrict psenc,
|
|
size_t * __restrict nresult)
|
|
{
|
|
int i = 0;
|
|
size_t len;
|
|
_ISO2022Charset cs;
|
|
char *p;
|
|
char tmp[MB_LEN_MAX];
|
|
int target;
|
|
u_char mask;
|
|
int bit8;
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
_DIAGASSERT(string != NULL);
|
|
/* result may be NULL */
|
|
_DIAGASSERT(psenc != NULL);
|
|
_DIAGASSERT(nresult != NULL);
|
|
|
|
if (isc0(wc & 0xff)) {
|
|
/* go back to INIT0 or ASCII on control chars */
|
|
cs = ei->initg[0].final ? ei->initg[0] : ascii;
|
|
} else if (isc1(wc & 0xff)) {
|
|
/* go back to INIT1 or ISO-8859-1 on control chars */
|
|
cs = ei->initg[1].final ? ei->initg[1] : iso88591;
|
|
} else if (!(wc & ~0xff)) {
|
|
if (wc & 0x80) {
|
|
/* special treatment for ISO-8859-1 */
|
|
cs = iso88591;
|
|
} else {
|
|
/* special treatment for ASCII */
|
|
cs = ascii;
|
|
}
|
|
} else {
|
|
cs.final = (wc >> 24) & 0x7f;
|
|
if ((wc >> 16) & 0x80)
|
|
cs.interm = (wc >> 16) & 0x7f;
|
|
else
|
|
cs.interm = '\0';
|
|
if (wc & 0x80)
|
|
cs.type = (wc & 0x00007f00) ? CS96MULTI : CS96;
|
|
else
|
|
cs.type = (wc & 0x00007f00) ? CS94MULTI : CS94;
|
|
}
|
|
target = recommendation(ei, &cs);
|
|
p = tmp;
|
|
bit8 = ei->flags & F_8BIT;
|
|
|
|
/* designate the charset onto the target plane(G0/1/2/3). */
|
|
if (psenc->g[target].type == cs.type
|
|
&& psenc->g[target].final == cs.final
|
|
&& psenc->g[target].interm == cs.interm)
|
|
goto planeok;
|
|
|
|
*p++ = '\033';
|
|
if (cs.type == CS94MULTI || cs.type == CS96MULTI)
|
|
*p++ = '$';
|
|
if (target == 0 && cs.type == CS94MULTI && strchr("@AB", cs.final)
|
|
&& !cs.interm && !(ei->flags & F_NOOLD))
|
|
;
|
|
else if (cs.type == CS94 || cs.type == CS94MULTI)
|
|
*p++ = "()*+"[target];
|
|
else
|
|
*p++ = ",-./"[target];
|
|
if (cs.interm)
|
|
*p++ = cs.interm;
|
|
*p++ = cs.final;
|
|
|
|
psenc->g[target].type = cs.type;
|
|
psenc->g[target].final = cs.final;
|
|
psenc->g[target].interm = cs.interm;
|
|
|
|
planeok:
|
|
/* invoke the plane onto GL or GR. */
|
|
if (psenc->gl == target)
|
|
goto sideok;
|
|
if (bit8 && psenc->gr == target)
|
|
goto sideok;
|
|
|
|
if (target == 0 && (ei->flags & F_LS0)) {
|
|
*p++ = '\017';
|
|
psenc->gl = 0;
|
|
} else if (target == 1 && (ei->flags & F_LS1)) {
|
|
*p++ = '\016';
|
|
psenc->gl = 1;
|
|
} else if (target == 2 && (ei->flags & F_LS2)) {
|
|
*p++ = '\033';
|
|
*p++ = 'n';
|
|
psenc->gl = 2;
|
|
} else if (target == 3 && (ei->flags & F_LS3)) {
|
|
*p++ = '\033';
|
|
*p++ = 'o';
|
|
psenc->gl = 3;
|
|
} else if (bit8 && target == 1 && (ei->flags & F_LS1R)) {
|
|
*p++ = '\033';
|
|
*p++ = '~';
|
|
psenc->gr = 1;
|
|
} else if (bit8 && target == 2 && (ei->flags & F_LS2R)) {
|
|
*p++ = '\033';
|
|
/*{*/
|
|
*p++ = '}';
|
|
psenc->gr = 2;
|
|
} else if (bit8 && target == 3 && (ei->flags & F_LS3R)) {
|
|
*p++ = '\033';
|
|
*p++ = '|';
|
|
psenc->gr = 3;
|
|
} else if (target == 2 && (ei->flags & F_SS2)) {
|
|
*p++ = '\033';
|
|
*p++ = 'N';
|
|
psenc->singlegl = 2;
|
|
} else if (target == 3 && (ei->flags & F_SS3)) {
|
|
*p++ = '\033';
|
|
*p++ = 'O';
|
|
psenc->singlegl = 3;
|
|
} else if (bit8 && target == 2 && (ei->flags & F_SS2R)) {
|
|
*p++ = '\216';
|
|
*p++ = 'N';
|
|
psenc->singlegl = psenc->singlegr = 2;
|
|
} else if (bit8 && target == 3 && (ei->flags & F_SS3R)) {
|
|
*p++ = '\217';
|
|
*p++ = 'O';
|
|
psenc->singlegl = psenc->singlegr = 3;
|
|
} else
|
|
goto ilseq;
|
|
|
|
sideok:
|
|
if (psenc->singlegl == target)
|
|
mask = 0x00;
|
|
else if (psenc->singlegr == target)
|
|
mask = 0x80;
|
|
else if (psenc->gl == target)
|
|
mask = 0x00;
|
|
else if ((ei->flags & F_8BIT) && psenc->gr == target)
|
|
mask = 0x80;
|
|
else
|
|
goto ilseq;
|
|
|
|
switch (cs.type) {
|
|
case CS94:
|
|
case CS96:
|
|
i = 1;
|
|
break;
|
|
case CS94MULTI:
|
|
case CS96MULTI:
|
|
i = !iscntl(wc & 0xff) ?
|
|
(isthree(cs.final) ? 3 : 2) : 1;
|
|
break;
|
|
}
|
|
while (i-- > 0)
|
|
*p++ = ((wc >> (i << 3)) & 0x7f) | mask;
|
|
|
|
/* reset single shift state */
|
|
psenc->singlegl = psenc->singlegr = -1;
|
|
|
|
len = (size_t)(p - tmp);
|
|
if (n < len) {
|
|
if (result)
|
|
*result = (char *)0;
|
|
*nresult = (size_t)-1;
|
|
return E2BIG;
|
|
}
|
|
if (result)
|
|
*result = string + len;
|
|
memcpy(string, tmp, len);
|
|
*nresult = len;
|
|
|
|
return 0;
|
|
|
|
ilseq:
|
|
*nresult = (size_t)-1;
|
|
return EILSEQ;
|
|
}
|
|
|
|
static int
|
|
_citrus_ISO2022_put_state_reset(_ISO2022EncodingInfo * __restrict ei,
|
|
char * __restrict s, size_t n,
|
|
_ISO2022State * __restrict psenc,
|
|
size_t * __restrict nresult)
|
|
{
|
|
char buf[MB_LEN_MAX];
|
|
char *result;
|
|
int ret;
|
|
size_t len;
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
_DIAGASSERT(nresult != 0);
|
|
_DIAGASSERT(s != NULL);
|
|
|
|
/* XXX state will be modified after this operation... */
|
|
ret = _ISO2022_sputwchar(ei, L'\0', buf, sizeof(buf), &result, psenc,
|
|
&len);
|
|
if (ret) {
|
|
*nresult = len;
|
|
return ret;
|
|
}
|
|
|
|
if (sizeof(buf) < len || n < len-1) {
|
|
/* XXX should recover state? */
|
|
*nresult = (size_t)-1;
|
|
return E2BIG;
|
|
}
|
|
|
|
memcpy(s, buf, len-1);
|
|
*nresult = len-1;
|
|
return (0);
|
|
}
|
|
|
|
static int
|
|
_citrus_ISO2022_wcrtomb_priv(_ISO2022EncodingInfo * __restrict ei,
|
|
char * __restrict s, size_t n, wchar_t wc,
|
|
_ISO2022State * __restrict psenc,
|
|
size_t * __restrict nresult)
|
|
{
|
|
char buf[MB_LEN_MAX];
|
|
char *result;
|
|
int ret;
|
|
size_t len;
|
|
|
|
_DIAGASSERT(ei != NULL);
|
|
_DIAGASSERT(s != NULL);
|
|
_DIAGASSERT(psenc != NULL);
|
|
_DIAGASSERT(nresult != 0);
|
|
|
|
/* XXX state will be modified after this operation... */
|
|
ret = _ISO2022_sputwchar(ei, wc, buf, sizeof(buf), &result, psenc,
|
|
&len);
|
|
if (ret) {
|
|
*nresult = len;
|
|
return ret;
|
|
}
|
|
|
|
if (sizeof(buf) < len || n < len) {
|
|
/* XXX should recover state? */
|
|
*nresult = (size_t)-1;
|
|
return E2BIG;
|
|
}
|
|
|
|
memcpy(s, buf, len);
|
|
*nresult = len;
|
|
return (0);
|
|
}
|
|
|
|
static __inline int
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_stdenc_wctocs(_ISO2022EncodingInfo * __restrict ei,
|
|
_csid_t * __restrict csid,
|
|
_index_t * __restrict idx, wchar_t wc)
|
|
{
|
|
wchar_t m, nm;
|
|
|
|
_DIAGASSERT(csid != NULL && idx != NULL);
|
|
|
|
m = wc & 0x7FFF8080;
|
|
nm = wc & 0x007F7F7F;
|
|
if (m & 0x00800000) {
|
|
nm &= 0x00007F7F;
|
|
} else {
|
|
m &= 0x7F008080;
|
|
}
|
|
if (nm & 0x007F0000) {
|
|
/* ^3 mark */
|
|
m |= 0x007F0000;
|
|
} else if (nm & 0x00007F00) {
|
|
/* ^2 mark */
|
|
m |= 0x00007F00;
|
|
}
|
|
*csid = (_csid_t)m;
|
|
*idx = (_index_t)nm;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static __inline int
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_stdenc_cstowc(_ISO2022EncodingInfo * __restrict ei,
|
|
wchar_t * __restrict wc,
|
|
_csid_t csid, _index_t idx)
|
|
{
|
|
|
|
_DIAGASSERT(ei != NULL && wc != NULL);
|
|
|
|
*wc = (wchar_t)(csid & 0x7F808080) | (wchar_t)idx;
|
|
|
|
return (0);
|
|
}
|
|
|
|
static __inline int
|
|
/*ARGSUSED*/
|
|
_citrus_ISO2022_stdenc_get_state_desc_generic(_ISO2022EncodingInfo * __restrict ei,
|
|
_ISO2022State * __restrict psenc,
|
|
int * __restrict rstate)
|
|
{
|
|
|
|
if (psenc->chlen == 0) {
|
|
/* XXX: it should distinguish initial and stable. */
|
|
*rstate = _STDENC_SDGEN_STABLE;
|
|
} else {
|
|
if (psenc->ch[0] == '\033')
|
|
*rstate = _STDENC_SDGEN_INCOMPLETE_SHIFT;
|
|
else
|
|
*rstate = _STDENC_SDGEN_INCOMPLETE_CHAR;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* public interface for ctype
|
|
*/
|
|
|
|
_CITRUS_CTYPE_DECLS(ISO2022);
|
|
_CITRUS_CTYPE_DEF_OPS(ISO2022);
|
|
|
|
#include "citrus_ctype_template.h"
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* public interface for stdenc
|
|
*/
|
|
|
|
_CITRUS_STDENC_DECLS(ISO2022);
|
|
_CITRUS_STDENC_DEF_OPS(ISO2022);
|
|
|
|
#include "citrus_stdenc_template.h"
|