/* Copyright 1989, 1998 The Open Group Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Except as contained in this notice, the name of The Open Group shall not be used in advertising or otherwise to promote the sale, use or other dealings in this Software without prior written authorization from The Open Group. */ #ifdef HAVE_CONFIG_H #include <config.h> #endif #include <X11/Xfuncs.h> #include "Xct.h" #include <stdio.h> #define UsedGraphic 0x0001 #define UsedDirection 0x0002 typedef struct _XctPriv { XctString ptr; XctString ptrend; unsigned flags; XctHDirection *dirstack; unsigned dirsize; char **encodings; unsigned enc_count; XctString itembuf; unsigned buf_count; } *XctPriv; #define IsMore(priv) ((priv)->ptr != (priv)->ptrend) #define AmountLeft(priv) ((priv)->ptrend - (priv)->ptr) #include <stdlib.h> #define HT 0x09 #define NL 0x0a #define ESC 0x1b #define CSI 0x9b #define IsLegalC0(data, c) (((c) == HT) || ((c) == NL) || \ (((data)->version > XctVersion) && \ ((data)->flags & XctAcceptC0Extensions))) #define IsLegalC1(priv, c) (((data)->version > XctVersion) && \ ((data)->flags & XctAcceptC1Extensions)) #define IsI2(c) (((c) >= 0x20) && ((c) <= 0x2f)) #define IsI3(c) (((c) >= 0x30) && ((c) <= 0x3f)) #define IsESCF(c) (((c) >= 0x30) && ((c) <= 0x7e)) #define IsCSIF(c) (((c) >= 0x40) && ((c) <= 0x7e)) #define IsC0(c) ((c) <= 0x1f) #define IsGL(c) (((c) >= 0x20) && ((c) <= 0x7f)) #define IsC1(c) (((c) >= 0x80) && ((c) <= 0x9f)) #define IsGR(c) ((c) >= 0xa0) #define HasC 1 #define HasGL 2 #define HasGR 4 #define ToGL 8 /* * Prototypes */ static void ComputeGLGR(XctData); static int Handle94GR(XctData, int); static int Handle96GR(XctData, int); static int HandleExtended(XctData data, int); static int HandleGL(XctData, int); static int HandleMultiGL(XctData, int); static int HandleMultiGR(XctData data, int); static void ShiftGRToGL(XctData, int); /* * Implementation */ static void ComputeGLGR(register XctData data) { /* XXX this will need more work if more sets are registered */ if ((data->GL_set_size == 94) && (data->GL_char_size == 1) && (data->GL[0] == '\102') && (data->GR_set_size == 96) && (data->GR_char_size == 1)) data->GLGR_encoding = data->GR_encoding; else if ((data->GL_set_size == 94) && (data->GL_char_size == 1) && (data->GL[0] == '\112') && (data->GR_set_size == 94) && (data->GR_char_size == 1)) data->GLGR_encoding = data->GR_encoding; else data->GLGR_encoding = (char *)NULL; } static int HandleGL(register XctData data, int c) { switch (c) { case 0x42: data->GL = "\102"; data->GL_encoding = "ISO8859-1"; break; case 0x4a: data->GL = "\112"; data->GL_encoding = "JISX0201.1976-0"; break; default: return 0; } data->GL_set_size = 94; data->GL_char_size = 1; ComputeGLGR(data); return 1; } static int HandleMultiGL(register XctData data, int c) { switch (c) { case 0x41: data->GL = "\101"; data->GL_encoding = "GB2312.1980-0"; break; case 0x42: data->GL = "\102"; data->GL_encoding = "JISX0208.1983-0"; break; case 0x43: data->GL = "\103"; data->GL_encoding = "KSC5601.1987-0"; break; default: return 0; } data->GL_set_size = 94; data->GL_char_size = 2; #ifdef notdef if (c < 0x60) data->GL_char_size = 2; else if (c < 0x70) data->GL_char_size = 3; else data->GL_char_size = 4; #endif data->GLGR_encoding = (char *)NULL; return 1; } static int Handle94GR(register XctData data, int c) { switch (c) { case 0x49: data->GR = "\111"; data->GR_encoding = "JISX0201.1976-0"; break; default: return 0; } data->priv->flags &= ~ToGL; data->GR_set_size = 94; data->GR_char_size = 1; data->GLGR_encoding = (char *)NULL; return 1; } static int Handle96GR(register XctData data, int c) { switch (c) { case 0x41: data->GR = "\101"; data->GR_encoding = "ISO8859-1"; break; case 0x42: data->GR = "\102"; data->GR_encoding = "ISO8859-2"; break; case 0x43: data->GR = "\103"; data->GR_encoding = "ISO8859-3"; break; case 0x44: data->GR = "\104"; data->GR_encoding = "ISO8859-4"; break; case 0x46: data->GR = "\106"; data->GR_encoding = "ISO8859-7"; break; case 0x47: data->GR = "\107"; data->GR_encoding = "ISO8859-6"; break; case 0x48: data->GR = "\110"; data->GR_encoding = "ISO8859-8"; break; case 0x4c: data->GR = "\114"; data->GR_encoding = "ISO8859-5"; break; case 0x4d: data->GR = "\115"; data->GR_encoding = "ISO8859-9"; break; default: return 0; } data->priv->flags &= ~ToGL; data->GR_set_size = 96; data->GR_char_size = 1; ComputeGLGR(data); return 1; } static int HandleMultiGR(register XctData data, int c) { switch (c) { case 0x41: data->GR = "\101"; if (data->flags & XctShiftMultiGRToGL) data->GR_encoding = "GB2312.1980-0"; else data->GR_encoding = "GB2312.1980-1"; break; case 0x42: data->GR = "\102"; if (data->flags & XctShiftMultiGRToGL) data->GR_encoding = "JISX0208.1983-0"; else data->GR_encoding = "JISX0208.1983-1"; break; case 0x43: data->GR = "\103"; if (data->flags & XctShiftMultiGRToGL) data->GR_encoding = "KSC5601.1987-0"; else data->GR_encoding = "KSC5601.1987-1"; break; default: return 0; } if (data->flags & XctShiftMultiGRToGL) data->priv->flags |= ToGL; else data->priv->flags &= ~ToGL; data->GR_set_size = 94; data->GR_char_size = 2; #ifdef notdef if (c < 0x60) data->GR_char_size = 2; else if (c < 0x70) data->GR_char_size = 3; else data->GR_char_size = 4; #endif data->GLGR_encoding = (char *)NULL; return 1; } static int HandleExtended(register XctData data, int c) { register XctPriv priv = data->priv; XctString enc = data->item + 6; register XctString ptr = enc; unsigned i, len; while (*ptr != 0x02) { if (!*ptr || (++ptr == priv->ptr)) return 0; } data->item = ptr + 1; data->item_length = priv->ptr - data->item; len = ptr - enc; for (i = 0; (i < priv->enc_count) && strncmp(priv->encodings[i], (char *)enc, len); i++) ; if (i == priv->enc_count) { XctString cp; for (cp = enc; cp != ptr; cp++) { if ((!IsGL(*cp) && !IsGR(*cp)) || (*cp == 0x2a) || (*cp == 0x3f)) return 0; } ptr = (XctString)malloc((unsigned)len + 1); (void) memmove((char *)ptr, (char *)enc, len); ptr[len] = 0x00; priv->enc_count++; if (priv->encodings) priv->encodings = (char **)realloc( (char *)priv->encodings, priv->enc_count * sizeof(char *)); else priv->encodings = (char **)malloc(sizeof(char *)); priv->encodings[i] = (char *)ptr; } data->encoding = priv->encodings[i]; data->char_size = c - 0x30; return 1; } static void ShiftGRToGL(register XctData data, int hasCdata) { register XctPriv priv = data->priv; register int i; if (data->item_length > priv->buf_count) { priv->buf_count = data->item_length; if (priv->itembuf) priv->itembuf = (XctString)realloc((char *)priv->itembuf, priv->buf_count); else priv->itembuf = (XctString)malloc(priv->buf_count); } (void) memmove((char *)priv->itembuf, (char *)data->item, data->item_length); data->item = priv->itembuf; if (hasCdata) { for (i = data->item_length; --i >= 0; ) { if (IsGR(data->item[i])) data->item[i] &= 0x7f; } } else { for (i = data->item_length; --i >= 0; ) data->item[i] &= 0x7f; } } /* Create an XctData structure for parsing a Compound Text string. */ XctData XctCreate(_Xconst unsigned char *string, int length, XctFlags flags) { register XctData data; register XctPriv priv; data = (XctData)malloc(sizeof(struct _XctRec) + sizeof(struct _XctPriv)); if (!data) return data; data->priv = priv = (XctPriv)(data + 1); data->total_string = (XctString)string; data->total_length = length; data->flags = flags; priv->dirstack = (XctHDirection *)NULL; priv->dirsize = 0; priv->encodings = (char **)NULL; priv->enc_count = 0; priv->itembuf = (XctString)NULL; priv->buf_count = 0; XctReset(data); return data; } /* Reset the XctData structure to re-parse the string from the beginning. */ void XctReset(register XctData data) { register XctPriv priv = data->priv; priv->ptr = data->total_string; priv->ptrend = data->total_string + data->total_length; data->item = (XctString)NULL; data->item_length = 0; data->encoding = (char *)NULL; data->char_size = 1; data->horizontal = XctUnspecified; data->horz_depth = 0; priv->flags = 0; data->GL_set_size = data->GR_set_size = 0; /* XXX */ (void)HandleGL(data, (unsigned char)0x42); (void)Handle96GR(data, (unsigned char)0x41); data->version = 1; data->can_ignore_exts = 0; /* parse version, if present */ if ((data->total_length >= 4) && (priv->ptr[0] == ESC) && (priv->ptr[1] == 0x23) && IsI2(priv->ptr[2]) && ((priv->ptr[3] == 0x30) || (priv->ptr[3] == 0x31))) { data->version = priv->ptr[2] - 0x1f; if (priv->ptr[3] == 0x30) data->can_ignore_exts = 1; priv->ptr += 4; } } /* Parse the next "item" from the Compound Text string. The return value * indicates what kind of item is returned. The item itself, and the current * contextual state, are reported as components of the XctData structure. */ XctResult XctNextItem(register XctData data) { register XctPriv priv = data->priv; unsigned char c; int len, bits; #define NEXT data->item_length++; priv->ptr++ while (IsMore(priv)) { data->item = priv->ptr; data->item_length = 0; c = *priv->ptr; if (c == ESC) { NEXT; while (IsMore(priv) && IsI2(*priv->ptr)) { NEXT; } if (!IsMore(priv)) return XctError; c = *priv->ptr; NEXT; if (!IsESCF(c)) return XctError; switch (data->item[1]) { case 0x24: if (data->item_length > 3) { if (data->item[2] == 0x28) { if (HandleMultiGL(data, c)) continue; } else if (data->item[2] == 0x29) { if (HandleMultiGR(data, c)) continue; } } break; case 0x25: if ((data->item_length == 4) && (data->item[2] == 0x2f) && (c <= 0x3f)) { if ((AmountLeft(priv) < 2) || (priv->ptr[0] < 0x80) || (priv->ptr[1] < 0x80)) return XctError; len = *priv->ptr - 0x80; NEXT; len = (len << 7) + (*priv->ptr - 0x80); NEXT; if (AmountLeft(priv) < len) return XctError; data->item_length += len; priv->ptr += len; if (c <= 0x34) { if (!HandleExtended(data, c) || ((data->horz_depth == 0) && (priv->flags & UsedDirection))) return XctError; priv->flags |= UsedGraphic; return XctExtendedSegment; } } break; case 0x28: if (HandleGL(data, c)) continue; break; case 0x29: if (Handle94GR(data, c)) continue; break; case 0x2d: if (Handle96GR(data, c)) continue; break; } } else if (c == CSI) { NEXT; while (IsMore(priv) && IsI3(*priv->ptr)) { NEXT; } while (IsMore(priv) && IsI2(*priv->ptr)) { NEXT; } if (!IsMore(priv)) return XctError; c = *priv->ptr; NEXT; if (!IsCSIF(c)) return XctError; if (c == 0x5d) { if ((data->item_length == 3) && ((data->item[1] == 0x31) || (data->item[1] == 0x32))) { data->horz_depth++; if (priv->dirsize < data->horz_depth) { priv->dirsize += 10; if (priv->dirstack) priv->dirstack = (XctHDirection *) realloc((char *)priv->dirstack, priv->dirsize * sizeof(XctHDirection)); else priv->dirstack = (XctHDirection *) malloc(priv->dirsize * sizeof(XctHDirection)); } priv->dirstack[data->horz_depth - 1] = data->horizontal; if (data->item[1] == 0x31) data->horizontal = XctLeftToRight; else data->horizontal = XctRightToLeft; if ((priv->flags & UsedGraphic) && !(priv->flags & UsedDirection)) return XctError; priv->flags |= UsedDirection; if (data->flags & XctHideDirection) continue; return XctHorizontal; } else if (data->item_length == 2) { if (!data->horz_depth) return XctError; data->horz_depth--; data->horizontal = priv->dirstack[data->horz_depth]; if (data->flags & XctHideDirection) continue; return XctHorizontal; } } } else if (data->flags & XctSingleSetSegments) { NEXT; if IsC0(c) { data->encoding = (char *)NULL; data->char_size = 1; if (IsLegalC0(data, c)) return XctC0Segment; } else if (IsGL(c)) { data->encoding = data->GL_encoding; data->char_size = data->GL_char_size; while (IsMore(priv) && IsGL(*priv->ptr)) { NEXT; } if (((data->char_size > 1) && (data->item_length % data->char_size)) || ((data->horz_depth == 0) && (priv->flags & UsedDirection))) return XctError; priv->flags |= UsedGraphic; return XctGLSegment; } else if (IsC1(c)) { data->encoding = (char *)NULL; data->char_size = 1; if (IsLegalC1(data, c)) return XctC1Segment; } else { data->encoding = data->GR_encoding; data->char_size = data->GR_char_size; while (IsMore(priv) && IsGR(*priv->ptr)) { NEXT; } if (((data->char_size > 1) && (data->item_length % data->char_size)) || ((data->horz_depth == 0) && (priv->flags & UsedDirection))) return XctError; priv->flags |= UsedGraphic; if (!(priv->flags & ToGL)) return XctGRSegment; ShiftGRToGL(data, 0); return XctGLSegment; } } else { bits = 0; while (1) { if (IsC0(c) || IsC1(c)) { if ((c == ESC) || (c == CSI)) break; if (IsC0(c) ? !IsLegalC0(data, c) : !IsLegalC1(data, c)) break; bits |= HasC; NEXT; } else { len = data->item_length; if (IsGL(c)) { if ((data->flags & XctShiftMultiGRToGL) && (bits & HasGR)) break; NEXT; bits |= HasGL; while (IsMore(priv) && IsGL(*priv->ptr)) { NEXT; } if ((data->GL_char_size > 1) && ((data->item_length - len) % data->GL_char_size)) return XctError; } else { if ((data->flags & XctShiftMultiGRToGL) && (bits & HasGL)) break; NEXT; bits |= HasGR; while (IsMore(priv) && IsGR(*priv->ptr)) { NEXT; } if ((data->GR_char_size > 1) && ((data->item_length - len) % data->GR_char_size)) return XctError; } } if (!IsMore(priv)) break; c = *priv->ptr; } if (data->item_length) { if (bits & (HasGL|HasGR)) { priv->flags |= UsedGraphic; if ((data->horz_depth == 0) && (priv->flags & UsedDirection)) return XctError; if ((data->flags & XctShiftMultiGRToGL) && (bits & HasGR)) ShiftGRToGL(data, bits & HasC); } if ((bits == (HasGL|HasGR)) || (data->GLGR_encoding && !(bits & HasC))) { data->encoding = data->GLGR_encoding; if (data->GL_char_size == data->GR_char_size) data->char_size = data->GL_char_size; else data->char_size = 0; } else if (bits == HasGL) { data->encoding = data->GL_encoding; data->char_size = data->GL_char_size; } else if (bits == HasGR) { data->encoding = data->GR_encoding; data->char_size = data->GR_char_size; } else { data->encoding = (char *)NULL; data->char_size = 1; if ((bits & HasGL) && (data->GL_char_size != data->char_size)) data->char_size = 0; if ((bits & HasGR) && (data->GR_char_size != data->char_size)) data->char_size = 0; } return XctSegment; } NEXT; } if (data->version <= XctVersion) return XctError; if (data->flags & XctProvideExtensions) return XctExtension; if (!data->can_ignore_exts) return XctError; } return XctEndOfText; } /* Free all data associated with an XctDataStructure. */ void XctFree(register XctData data) { unsigned i; register XctPriv priv = data->priv; if (priv->dirstack) free((char *)priv->dirstack); if (data->flags & XctFreeString) free((char *)data->total_string); for (i = 0; i < priv->enc_count; i++) free(priv->encodings[i]); if (priv->encodings) free((char *)priv->encodings); if (priv->itembuf) free((char *)priv->itembuf); free((char *)data); }