xcnvmbtoct.c

早期freebsd实现

          case ESC:
            /* parse the control escape sequence of CT encoding. */
            switch (_XParseISOEncoding(ct_str, ct_bytes, &len, &stateinfo)) {
              case Success:
		if (*(ct_str+1) == 0x25) {
		/* Extend segmant */
		    int tmplen = limit - mbcnt;
		    int ret;
		    if((ret = _XConvertCTextToMB(xlocale, ct_str, ct_bytes,
					mb_str, &tmplen, &len)) < 0)
			Return(ret);
		    error += ret;
		    mb_str += tmplen;
		    mbcnt +=tmplen;
		    ct_str += len, ct_bytes -= len, ctcnt += len;
		    continue;
		}
                /*
                 * In mose case the control sequence is new one, so we
                 * set it to current state directly, enhance little speed
                 * without no comparision.
                 *
                */
                (void) strncpy(seq, (char *)ct_str, len);
                seq[len] = '\0';
                if (_XcwEscSetStatus(xlocale, seq) == False)
		    /* not register encoding by X. */
		    Return (BadEncoding);
                ct_str += len, ct_bytes -= len, ctcnt += len;
                continue;
              case BadEncoding:
                /*
                 * wrong escape sequence, the function can not recover
                 * this error, return it.
                */
                Return(BadEncoding);
              case BadTerminate:
                Return(BadTerminate);
              default:  /* never go to here */
                Return(BadEncoding);
                ;
            }
          default:
_Normal_char:
	    ctSetGLorGR(xlocale, byte&0x80);
	    ctid = ctGetid(xlocale);
	    
	    tmp = 0;
	    if ((newcsid = _Xmbctidtocsid(xlocale, ctid)) == ND) {
		/* Retry one more: There are some charset which
		   can be designated GL or GR. */
		char *esc;
		_XcwIdGetEncoding(xlocale, &esc);
		strcpy(seq, esc);
		if (seq[1] == '$' && seq[3] >= 'A' && seq[3] <= 'D') {
		    if (seq[2] == '(') {
			tmp = 1; seq[2] = ')'; byte |= 0x80;
		    } else if (seq[2] == ')') {
			tmp = 2; seq[2] = '('; byte &= 0x7f;
		    } else {
			Return(BadEncoding);
		    }
		    _XcwEscSetStatus(xlocale, seq);
		    ctSetGLorGR(xlocale, byte&0x80);
		    ctid = ctGetid(xlocale);
		    newcsid = _Xmbctidtocsid(xlocale, ctid);
		}
		if (newcsid == ND) {
		    /* XXX BUG: if stateful encoding, need to check/add
				designate sequence of default string.
		       But current default string is NULL, so OK. :-) */
		    for (i = 0; *(defstr + i) != 0; i++) {
			SaveStore(*(defstr + i))
		    }
		    ct_str += stateinfo.code_bytes;
		    ct_bytes -= stateinfo.code_bytes;
		    ctcnt += stateinfo.code_bytes;
		    error++;
		    continue;
		}
	    }
	    _XmbSetCsid(xlocale, newcsid);
	    if (newcsid != csid_sv) {
		int	mbGLorGR;
                if (_Xmbtype(xlocale) == CDS_STATEFUL &&
		    ((mbGLorGR = mbGetGLorGR(xlocale)) == GL &&
		      mbGetGLid(xlocale) != (state_sv & 0xff) ||
		     mbGLorGR == GR &&
		      mbGetGRid(xlocale) != (state_sv >> 8 & 0xff))) {
                    /*
                     * append designation of state-dependent codeset.
                     */
                    char *dsg;
                    int   dslen;

                    dsg = _Xmbdsg(xlocale);
                    dslen = strlen(dsg);
                    if (mbcnt + dslen > limit)
			Return(BadBuffer);
                    strncpy((char *)mb_str, dsg, dslen);
                    mb_str += dslen, mbcnt += dslen;
		    state_sv = xlocale->mb_state;
                }
		csid_sv = newcsid;
                codelen = _Xmblen(xlocale);
		_XcwIdGetISOState(xlocale, &stateinfo);
	    }
            /* get codepoint of character. */
            code = 0;
            switch (stateinfo.code_bytes) {
              case 4:
                    CombineCode(code);
              case 3:
                    CombineCode(code);
              case 2:
                    CombineCode(code);
              case 1:
		    if (tmp == 1)	byte |= 0x80;
		    else if (tmp == 2)	byte &= 0x7f;
		    if (byte < stateinfo.code_min ||
			byte > stateinfo.code_max) {
			error++;
			byte = stateinfo.code_min;
		    }
		    code = (code << 8) | byte;

                    ct_str++, ct_bytes--;
                    break;
            }
            if (_Xcsctombc(xlocale, code, &mbcode) < 0)
                error++;
            for (i = codelen - 1; i >= 0; i--)
                SaveStore((mbcode >> (i * 8)) & 0x00FF);
            /*
             * advance the ctcnt without any error.
             */
            ctcnt += stateinfo.code_bytes;
        }
    }
    if (_Xmbtype(xlocale) == CDS_STATEFUL) {
	/*
	 * add designation sequence.
	 */
	int     dsglen;

	_XmbGetDefaultEncoding(xlocale, seq);
	dsglen = strlen(seq);
	if (mbcnt + dsglen > limit)
	    Return(BadBuffer);
	strncpy((char *)mb_str, seq, dsglen);
	mb_str += dsglen, mbcnt += dsglen;
    }
    _Xmbinit(xlocale);
    Return(Success);
}

#undef Return
#undef CombineCode

#define Return(result) {                                                \
        *mb_bytes = mbcnt;                                              \
        *scanned_bytes = ctcnt;                                         \
	if (mbcnt < limit)						\
	    *mb_str = 0;						\
        if (error > 0) return (error);                                  \
        return (result);                                                \
    }

/*
 * CombineCode():
 *   concatenate the byte with code if the byte is valid.
*/
#define CombineCode(code) {                                             \
        code = (code << 8) | byte;                                      \
        ct_str++; ct_bytes--;						\
        if (ct_bytes < 1)                                               \
            Return(BadTerminate);                                       \
        byte = *ct_str;                                                 \
    }

static int
_XConvertCTextToMB(xlocale, ct_str, ct_bytes, mb_str, mb_bytes, scanned_bytes)
    XLocale xlocale;
    unsigned char   *ct_str;
    int              ct_bytes;
    unsigned char   *mb_str;
    int             *mb_bytes;
    int             *scanned_bytes;
{
    register unsigned char byte;
    int         mbcnt, ctcnt, codelen;
    int         i, code, mbcode, len, limit, error;
    char seq[128];
    int textlen;
    int bytes;
    _CSID csid, ctid;
    _State state_sv;
    char *defstr = XDefaultString();

    state_sv = xlocale->ct_state;
    limit = *mb_bytes;
    mbcnt = ctcnt = error = 0;

    if((len = _XctIsExtendSegment(xlocale, ct_str, &textlen, &bytes)) <= 0)
	/* not register encoding by X. */
	Return(BadEncoding);
    ct_str += len; ctcnt += len; ct_bytes -=len;

    if (ct_bytes < textlen)
	Return(BadTerminate) /* Nor enough data. What should do? */

    if (_Xmbtype(xlocale) == CDS_STATEFUL) {
	/* append designation of state-dependent codeset. */
	char *dsg;
	int   dslen;

	dsg = _Xmbdsg(xlocale);
	dslen = strlen(dsg);
	if (mbcnt + dslen > limit)
	    Return(BadBuffer);
	strncpy((char *)mb_str, dsg, dslen);
	mb_str += dslen, mbcnt += dslen;
    }

    ctid = ctGetid(xlocale);
    csid = _Xmbctidtocsid(xlocale, ctid);
    if (csid == ND) {
	int j;
	for (j = textlen/bytes; j > 0; j--) {
	    for (i = 0; *(defstr + i) != 0; i++) {
		SaveStore(*(defstr + i));
	    }
	    error++;
	}
	ctcnt += textlen;
	Return(Success);
    }
    _XmbSetCsid(xlocale, csid);
    codelen = _Xmblen(xlocale);

    while (textlen > 0) {
	/* get codepoint of character. */
	code = 0;
	byte = *ct_str;
	switch (bytes) {
	  case 4: CombineCode(code);
	  case 3: CombineCode(code);
	  case 2: CombineCode(code);
	  case 1:
		code = (code << 8) | byte;
		ct_str++; ct_bytes--;
		break;
	}
	textlen -= bytes;
	if (_Xcsctombc(xlocale, code, &mbcode) < 0)
	    error++;
	for (i = codelen - 1; i >= 0; i--)
	    SaveStore((mbcode >> (i * 8)) & 0x00FF);
	ctcnt += bytes;
    }
    if (_Xmbtype(xlocale) == CDS_STATEFUL) {
	/* add designation sequence. */
	int     dsglen;

	_XmbGetDefaultEncoding(xlocale, seq);
	dsglen = strlen(seq);
	if (mbcnt + dsglen > limit)
	    Return(BadBuffer);
	strncpy((char *)mb_str, seq, dsglen);
	mb_str += dsglen, mbcnt += dsglen;
    }
    xlocale->ct_state = state_sv;
    Return(Success);
}