aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/modules/im/ximcp/imLcPrs.c
diff options
context:
space:
mode:
authorMike Gabriel <mike.gabriel@das-netzwerkteam.de>2017-07-21 12:31:09 +0200
committerMike Gabriel <mike.gabriel@das-netzwerkteam.de>2017-08-25 10:06:49 +0200
commitc350873c7c977efe5210484f04160be45f84ba7e (patch)
tree717d33eb315f4def1307d65108d14715696cd5cf /nx-X11/lib/modules/im/ximcp/imLcPrs.c
parent1472e7e37838f17b7ed948fa206e8c3434a9d346 (diff)
downloadnx-libs-c350873c7c977efe5210484f04160be45f84ba7e.tar.gz
nx-libs-c350873c7c977efe5210484f04160be45f84ba7e.tar.bz2
nx-libs-c350873c7c977efe5210484f04160be45f84ba7e.zip
Convert nx-X11/lib/ build flow from imake to autotools.
Diffstat (limited to 'nx-X11/lib/modules/im/ximcp/imLcPrs.c')
-rw-r--r--nx-X11/lib/modules/im/ximcp/imLcPrs.c741
1 files changed, 741 insertions, 0 deletions
diff --git a/nx-X11/lib/modules/im/ximcp/imLcPrs.c b/nx-X11/lib/modules/im/ximcp/imLcPrs.c
new file mode 100644
index 000000000..fa992e5d3
--- /dev/null
+++ b/nx-X11/lib/modules/im/ximcp/imLcPrs.c
@@ -0,0 +1,741 @@
+/******************************************************************
+
+ Copyright 1992 by Oki Technosystems Laboratory, Inc.
+ Copyright 1992 by Fuji Xerox Co., Ltd.
+
+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, and that the name of Oki Technosystems
+Laboratory and Fuji Xerox not be used in advertising or publicity
+pertaining to distribution of the software without specific, written
+prior permission.
+Oki Technosystems Laboratory and Fuji Xerox make no representations
+about the suitability of this software for any purpose. It is provided
+"as is" without express or implied warranty.
+
+OKI TECHNOSYSTEMS LABORATORY AND FUJI XEROX DISCLAIM ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL OKI TECHNOSYSTEMS
+LABORATORY AND FUJI XEROX BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
+OR PERFORMANCE OF THIS SOFTWARE.
+
+ Author: Yasuhiro Kawai Oki Technosystems Laboratory
+ Author: Kazunori Nishihara Fuji Xerox
+
+******************************************************************/
+
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <nx-X11/Xlib.h>
+#include <nx-X11/Xmd.h>
+#include <nx-X11/Xos.h>
+#include "Xlibint.h"
+#include "Xlcint.h"
+#include "Ximint.h"
+#include <sys/stat.h>
+#include <stdio.h>
+#include <limits.h>
+#include "pathmax.h"
+
+#define XLC_BUFSIZE 256
+
+extern int _Xmbstowcs(
+ wchar_t *wstr,
+ char *str,
+ int len
+);
+
+extern int _Xmbstoutf8(
+ char *ustr,
+ const char *str,
+ int len
+);
+
+static void parsestringfile(FILE *fp, Xim im, int depth);
+
+/*
+ * Parsing File Format:
+ *
+ * FILE ::= { [PRODUCTION] [COMMENT] "\n"}
+ * PRODUCTION ::= LHS ":" RHS [ COMMENT ]
+ * COMMENT ::= "#" {<any character except null or newline>}
+ * LHS ::= EVENT { EVENT }
+ * EVENT ::= [MODIFIER_LIST] "<" keysym ">"
+ * MODIFIER_LIST ::= (["!"] {MODIFIER} ) | "None"
+ * MODIFIER ::= ["~"] MODIFIER_NAME
+ * MODIFIER_NAME ::= ("Ctrl"|"Lock"|"Caps"|"Shift"|"Alt"|"Meta")
+ * RHS ::= ( STRING | keysym | STRING keysym )
+ * STRING ::= '"' { CHAR } '"'
+ * CHAR ::= GRAPHIC_CHAR | ESCAPED_CHAR
+ * GRAPHIC_CHAR ::= locale (codeset) dependent code
+ * ESCAPED_CHAR ::= ('\\' | '\"' | OCTAL | HEX )
+ * OCTAL ::= '\' OCTAL_CHAR [OCTAL_CHAR [OCTAL_CHAR]]
+ * OCTAL_CHAR ::= (0|1|2|3|4|5|6|7)
+ * HEX ::= '\' (x|X) HEX_CHAR [HEX_CHAR]]
+ * HEX_CHAR ::= (0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F|a|b|c|d|e|f)
+ *
+ */
+
+static int
+nextch(
+ FILE *fp,
+ int *lastch)
+{
+ int c;
+
+ if (*lastch != 0) {
+ c = *lastch;
+ *lastch = 0;
+ } else {
+ c = getc(fp);
+ if (c == '\\') {
+ c = getc(fp);
+ if (c == '\n') {
+ c = getc(fp);
+ } else {
+ ungetc(c, fp);
+ c = '\\';
+ }
+ }
+ }
+ return(c);
+}
+
+static void
+putbackch(
+ int c,
+ int *lastch)
+{
+ *lastch = c;
+}
+
+#define ENDOFFILE 0
+#define ENDOFLINE 1
+#define COLON 2
+#define LESS 3
+#define GREATER 4
+#define EXCLAM 5
+#define TILDE 6
+#define STRING 7
+#define KEY 8
+#define ERROR 9
+
+#ifndef isalnum
+#define isalnum(c) \
+ (('0' <= (c) && (c) <= '9') || \
+ ('A' <= (c) && (c) <= 'Z') || \
+ ('a' <= (c) && (c) <= 'z'))
+#endif
+
+static int
+nexttoken(
+ FILE *fp,
+ char *tokenbuf,
+ int *lastch)
+{
+ int c;
+ int token;
+ char *p;
+ int i, j;
+
+ while ((c = nextch(fp, lastch)) == ' ' || c == '\t') {
+ }
+ switch (c) {
+ case EOF:
+ token = ENDOFFILE;
+ break;
+ case '\n':
+ token = ENDOFLINE;
+ break;
+ case '<':
+ token = LESS;
+ break;
+ case '>':
+ token = GREATER;
+ break;
+ case ':':
+ token = COLON;
+ break;
+ case '!':
+ token = EXCLAM;
+ break;
+ case '~':
+ token = TILDE;
+ break;
+ case '"':
+ p = tokenbuf;
+ while ((c = nextch(fp, lastch)) != '"') {
+ if (c == '\n' || c == EOF) {
+ putbackch(c, lastch);
+ token = ERROR;
+ goto string_error;
+ } else if (c == '\\') {
+ c = nextch(fp, lastch);
+ switch (c) {
+ case '\\':
+ case '"':
+ *p++ = c;
+ break;
+ case 'n':
+ *p++ = '\n';
+ break;
+ case 'r':
+ *p++ = '\r';
+ break;
+ case 't':
+ *p++ = '\t';
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ i = c - '0';
+ c = nextch(fp, lastch);
+ for (j = 0; j < 2 && c >= '0' && c <= '7'; j++) {
+ i <<= 3;
+ i += c - '0';
+ c = nextch(fp, lastch);
+ }
+ putbackch(c, lastch);
+ *p++ = (char)i;
+ break;
+ case 'X':
+ case 'x':
+ i = 0;
+ for (j = 0; j < 2; j++) {
+ c = nextch(fp, lastch);
+ i <<= 4;
+ if (c >= '0' && c <= '9') {
+ i += c - '0';
+ } else if (c >= 'A' && c <= 'F') {
+ i += c - 'A' + 10;
+ } else if (c >= 'a' && c <= 'f') {
+ i += c - 'a' + 10;
+ } else {
+ putbackch(c, lastch);
+ i >>= 4;
+ break;
+ }
+ }
+ if (j == 0) {
+ token = ERROR;
+ goto string_error;
+ }
+ *p++ = (char)i;
+ break;
+ case EOF:
+ putbackch(c, lastch);
+ token = ERROR;
+ goto string_error;
+ default:
+ *p++ = c;
+ break;
+ }
+ } else {
+ *p++ = c;
+ }
+ }
+ *p = '\0';
+ token = STRING;
+ break;
+ case '#':
+ while ((c = nextch(fp, lastch)) != '\n' && c != EOF) {
+ }
+ if (c == '\n') {
+ token = ENDOFLINE;
+ } else {
+ token = ENDOFFILE;
+ }
+ break;
+ default:
+ if (isalnum(c) || c == '_' || c == '-') {
+ p = tokenbuf;
+ *p++ = c;
+ c = nextch(fp, lastch);
+ while (isalnum(c) || c == '_' || c == '-') {
+ *p++ = c;
+ c = nextch(fp, lastch);
+ }
+ *p = '\0';
+ putbackch(c, lastch);
+ token = KEY;
+ } else {
+ token = ERROR;
+ }
+ break;
+ }
+string_error:
+ return(token);
+}
+
+static long
+modmask(
+ char *name)
+{
+ struct _modtbl {
+ const char name[6];
+ long mask;
+ };
+
+ static const struct _modtbl tbl[] = {
+ { "Ctrl", ControlMask },
+ { "Lock", LockMask },
+ { "Caps", LockMask },
+ { "Shift", ShiftMask },
+ { "Alt", Mod1Mask },
+ { "Meta", Mod1Mask }};
+
+ int i, num_entries = sizeof (tbl) / sizeof (tbl[0]);
+
+ for (i = 0; i < num_entries; i++)
+ if (!strcmp (name, tbl[i].name))
+ return tbl[i].mask;
+
+ return 0;
+}
+
+static char*
+TransFileName(Xim im, char *name)
+{
+ char *home = NULL, *lcCompose = NULL;
+ char dir[XLC_BUFSIZE] = "";
+ char *i = name, *ret = NULL, *j;
+ size_t l = 0;
+
+ while (*i) {
+ if (*i == '%') {
+ i++;
+ switch (*i) {
+ case '%':
+ l++;
+ break;
+ case 'H':
+ if (home == NULL)
+ home = getenv("HOME");
+ if (home) {
+ size_t Hsize = strlen(home);
+ if (Hsize > PATH_MAX)
+ /* your home directory length is ridiculous */
+ goto end;
+ l += Hsize;
+ }
+ break;
+ case 'L':
+ if (lcCompose == NULL)
+ lcCompose = _XlcFileName(im->core.lcd, COMPOSE_FILE);
+ if (lcCompose) {
+ size_t Lsize = strlen(lcCompose);
+ if (Lsize > PATH_MAX)
+ /* your compose pathname length is ridiculous */
+ goto end;
+ l += Lsize;
+ }
+ break;
+ case 'S':
+ if (dir[0] == '\0')
+ xlocaledir(dir, XLC_BUFSIZE);
+ if (dir[0]) {
+ size_t Ssize = strlen(dir);
+ if (Ssize > PATH_MAX)
+ /* your locale directory path length is ridiculous */
+ goto end;
+ l += Ssize;
+ }
+ break;
+ }
+ } else {
+ l++;
+ }
+ i++;
+ if (l > PATH_MAX)
+ /* your expanded path length is ridiculous */
+ goto end;
+ }
+
+ j = ret = Xmalloc(l+1);
+ if (ret == NULL)
+ goto end;
+ i = name;
+ while (*i) {
+ if (*i == '%') {
+ i++;
+ switch (*i) {
+ case '%':
+ *j++ = '%';
+ break;
+ case 'H':
+ if (home) {
+ strcpy(j, home);
+ j += strlen(home);
+ }
+ break;
+ case 'L':
+ if (lcCompose) {
+ strcpy(j, lcCompose);
+ j += strlen(lcCompose);
+ }
+ break;
+ case 'S':
+ strcpy(j, dir);
+ j += strlen(dir);
+ break;
+ }
+ i++;
+ } else {
+ *j++ = *i++;
+ }
+ }
+ *j = '\0';
+end:
+ Xfree(lcCompose);
+ return ret;
+}
+
+#ifndef MB_LEN_MAX
+#define MB_LEN_MAX 6
+#endif
+
+static int
+get_mb_string (Xim im, char *buf, KeySym ks)
+{
+ XPointer from, to;
+ int from_len, to_len, len;
+ XPointer args[1];
+ XlcCharSet charset;
+ char local_buf[MB_LEN_MAX];
+ unsigned int ucs;
+ ucs = KeySymToUcs4(ks);
+
+ from = (XPointer) &ucs;
+ to = (XPointer) local_buf;
+ from_len = 1;
+ to_len = MB_LEN_MAX;
+ args[0] = (XPointer) &charset;
+ if (_XlcConvert(im->private.local.ucstoc_conv,
+ &from, &from_len, &to, &to_len, args, 1 ) != 0) {
+ return 0;
+ }
+
+ from = (XPointer) local_buf;
+ to = (XPointer) buf;
+ from_len = MB_LEN_MAX - to_len;
+ to_len = MB_LEN_MAX + 1;
+ args[0] = (XPointer) charset;
+ if (_XlcConvert(im->private.local.cstomb_conv,
+ &from, &from_len, &to, &to_len, args, 1 ) != 0) {
+ return 0;
+ }
+ len = MB_LEN_MAX + 1 - to_len;
+ buf[len] = '\0';
+ return len;
+}
+
+#define AllMask (ShiftMask | LockMask | ControlMask | Mod1Mask)
+#define LOCAL_WC_BUFSIZE 128
+#define LOCAL_UTF8_BUFSIZE 256
+#define SEQUENCE_MAX 10
+
+static int
+parseline(
+ FILE *fp,
+ Xim im,
+ char* tokenbuf,
+ int depth)
+{
+ int token;
+ DTModifier modifier_mask;
+ DTModifier modifier;
+ DTModifier tmp;
+ KeySym keysym = NoSymbol;
+ DTIndex *top = &im->private.local.top;
+ DefTreeBase *b = &im->private.local.base;
+ DTIndex t;
+ DefTree *p = NULL;
+ Bool exclam, tilde;
+ KeySym rhs_keysym = 0;
+ char *rhs_string_mb;
+ int l;
+ int lastch = 0;
+ char local_mb_buf[MB_LEN_MAX+1];
+ wchar_t local_wc_buf[LOCAL_WC_BUFSIZE], *rhs_string_wc;
+ char local_utf8_buf[LOCAL_UTF8_BUFSIZE], *rhs_string_utf8;
+
+ struct DefBuffer {
+ DTModifier modifier_mask;
+ DTModifier modifier;
+ KeySym keysym;
+ };
+
+ struct DefBuffer buf[SEQUENCE_MAX];
+ int i, n;
+
+ do {
+ token = nexttoken(fp, tokenbuf, &lastch);
+ } while (token == ENDOFLINE);
+
+ if (token == ENDOFFILE) {
+ return(-1);
+ }
+
+ n = 0;
+ do {
+ if ((token == KEY) && (strcmp("include", tokenbuf) == 0)) {
+ char *filename;
+ FILE *infp;
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token != KEY && token != STRING)
+ goto error;
+ if (++depth > 100)
+ goto error;
+ if ((filename = TransFileName(im, tokenbuf)) == NULL)
+ goto error;
+ infp = _XFopenFile(filename, "r");
+ Xfree(filename);
+ if (infp == NULL)
+ goto error;
+ parsestringfile(infp, im, depth);
+ fclose(infp);
+ return (0);
+ } else if ((token == KEY) && (strcmp("None", tokenbuf) == 0)) {
+ modifier = 0;
+ modifier_mask = AllMask;
+ token = nexttoken(fp, tokenbuf, &lastch);
+ } else {
+ modifier_mask = modifier = 0;
+ exclam = False;
+ if (token == EXCLAM) {
+ exclam = True;
+ token = nexttoken(fp, tokenbuf, &lastch);
+ }
+ while (token == TILDE || token == KEY) {
+ tilde = False;
+ if (token == TILDE) {
+ tilde = True;
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token != KEY)
+ goto error;
+ }
+ tmp = modmask(tokenbuf);
+ if (!tmp) {
+ goto error;
+ }
+ modifier_mask |= tmp;
+ if (tilde) {
+ modifier &= ~tmp;
+ } else {
+ modifier |= tmp;
+ }
+ token = nexttoken(fp, tokenbuf, &lastch);
+ }
+ if (exclam) {
+ modifier_mask = AllMask;
+ }
+ }
+
+ if (token != LESS) {
+ goto error;
+ }
+
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token != KEY) {
+ goto error;
+ }
+
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token != GREATER) {
+ goto error;
+ }
+
+ keysym = XStringToKeysym(tokenbuf);
+ if (keysym == NoSymbol) {
+ goto error;
+ }
+
+ buf[n].keysym = keysym;
+ buf[n].modifier = modifier;
+ buf[n].modifier_mask = modifier_mask;
+ n++;
+ if( n >= SEQUENCE_MAX )
+ goto error;
+ token = nexttoken(fp, tokenbuf, &lastch);
+ } while (token != COLON);
+
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token == STRING) {
+ l = strlen(tokenbuf) + 1;
+ while (b->mbused + l > b->mbsize) {
+ DTCharIndex newsize = b->mbsize ? b->mbsize * 1.5 : 1024;
+ char *newmb = Xrealloc (b->mb, newsize);
+ if (newmb == NULL)
+ goto error;
+ b->mb = newmb;
+ b->mbsize = newsize;
+ }
+ rhs_string_mb = &b->mb[b->mbused];
+ b->mbused += l;
+ strcpy(rhs_string_mb, tokenbuf);
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token == KEY) {
+ rhs_keysym = XStringToKeysym(tokenbuf);
+ if (rhs_keysym == NoSymbol) {
+ goto error;
+ }
+ token = nexttoken(fp, tokenbuf, &lastch);
+ }
+ if (token != ENDOFLINE && token != ENDOFFILE) {
+ goto error;
+ }
+ } else if (token == KEY) {
+ rhs_keysym = XStringToKeysym(tokenbuf);
+ if (rhs_keysym == NoSymbol) {
+ goto error;
+ }
+ token = nexttoken(fp, tokenbuf, &lastch);
+ if (token != ENDOFLINE && token != ENDOFFILE) {
+ goto error;
+ }
+
+ l = get_mb_string(im, local_mb_buf, rhs_keysym);
+ while (b->mbused + l + 1 > b->mbsize) {
+ DTCharIndex newsize = b->mbsize ? b->mbsize * 1.5 : 1024;
+ char *newmb = Xrealloc (b->mb, newsize);
+ if (newmb == NULL)
+ goto error;
+ b->mb = newmb;
+ b->mbsize = newsize;
+ }
+ rhs_string_mb = &b->mb[b->mbused];
+ b->mbused += l + 1;
+ memcpy(rhs_string_mb, local_mb_buf, l);
+ rhs_string_mb[l] = '\0';
+ } else {
+ goto error;
+ }
+
+ l = _Xmbstowcs(local_wc_buf, rhs_string_mb, LOCAL_WC_BUFSIZE - 1);
+ if (l == LOCAL_WC_BUFSIZE - 1) {
+ local_wc_buf[l] = (wchar_t)'\0';
+ }
+ while (b->wcused + l + 1 > b->wcsize) {
+ DTCharIndex newsize = b->wcsize ? b->wcsize * 1.5 : 512;
+ wchar_t *newwc = Xrealloc (b->wc, sizeof(wchar_t) * newsize);
+ if (newwc == NULL)
+ goto error;
+ b->wc = newwc;
+ b->wcsize = newsize;
+ }
+ rhs_string_wc = &b->wc[b->wcused];
+ b->wcused += l + 1;
+ memcpy((char *)rhs_string_wc, (char *)local_wc_buf, (l + 1) * sizeof(wchar_t) );
+
+ l = _Xmbstoutf8(local_utf8_buf, rhs_string_mb, LOCAL_UTF8_BUFSIZE - 1);
+ if (l == LOCAL_UTF8_BUFSIZE - 1) {
+ local_utf8_buf[l] = '\0';
+ }
+ while (b->utf8used + l + 1 > b->utf8size) {
+ DTCharIndex newsize = b->utf8size ? b->utf8size * 1.5 : 1024;
+ char *newutf8 = Xrealloc (b->utf8, newsize);
+ if (newutf8 == NULL)
+ goto error;
+ b->utf8 = newutf8;
+ b->utf8size = newsize;
+ }
+ rhs_string_utf8 = &b->utf8[b->utf8used];
+ b->utf8used += l + 1;
+ memcpy(rhs_string_utf8, local_utf8_buf, l + 1);
+
+ for (i = 0; i < n; i++) {
+ for (t = *top; t; t = b->tree[t].next) {
+ if (buf[i].keysym == b->tree[t].keysym &&
+ buf[i].modifier == b->tree[t].modifier &&
+ buf[i].modifier_mask == b->tree[t].modifier_mask) {
+ break;
+ }
+ }
+ if (t) {
+ p = &b->tree[t];
+ top = &p->succession;
+ } else {
+ while (b->treeused >= b->treesize) {
+ DefTree *old = b->tree;
+ int oldsize = b->treesize;
+ int newsize = b->treesize ? b->treesize * 1.5 : 256;
+ DefTree *new = Xrealloc (b->tree, sizeof(DefTree) * newsize);
+ if (new == NULL)
+ goto error;
+ b->tree = new;
+ b->treesize = newsize;
+ if (top >= (DTIndex *) old && top < (DTIndex *) &old[oldsize])
+ top = (DTIndex *) (((char *) top) + (((char *)b->tree)-(char *)old));
+ }
+ p = &b->tree[b->treeused];
+ p->keysym = buf[i].keysym;
+ p->modifier = buf[i].modifier;
+ p->modifier_mask = buf[i].modifier_mask;
+ p->succession = 0;
+ p->next = *top;
+ p->mb = 0;
+ p->wc = 0;
+ p->utf8 = 0;
+ p->ks = NoSymbol;
+ *top = b->treeused;
+ top = &p->succession;
+ b->treeused++;
+ }
+ }
+
+ /* old entries no longer freed... */
+ p->mb = rhs_string_mb - b->mb;
+ p->wc = rhs_string_wc - b->wc;
+ p->utf8 = rhs_string_utf8 - b->utf8;
+ p->ks = rhs_keysym;
+ return(n);
+error:
+ while (token != ENDOFLINE && token != ENDOFFILE) {
+ token = nexttoken(fp, tokenbuf, &lastch);
+ }
+ return(0);
+}
+
+void
+_XimParseStringFile(
+ FILE *fp,
+ Xim im)
+{
+ parsestringfile(fp, im, 0);
+}
+
+static void
+parsestringfile(
+ FILE *fp,
+ Xim im,
+ int depth)
+{
+ char tb[8192];
+ char* tbp;
+ struct stat st;
+
+ if (fstat (fileno (fp), &st) != -1) {
+ unsigned long size = (unsigned long) st.st_size;
+ if (st.st_size >= INT_MAX)
+ return;
+ if (size <= sizeof tb) tbp = tb;
+ else tbp = malloc (size);
+
+ if (tbp != NULL) {
+ while (parseline(fp, im, tbp, depth) >= 0) {}
+ if (tbp != tb) free (tbp);
+ }
+ }
+}