/* $XConsortium: lcDB.c /main/9 1995/12/01 11:53:25 kaleb $ */

/*

 * Copyright (c) 1996, 1998, 1999, 2001 by Sun Microsystems, Inc.

 * All rights reserved.

 */

#pragma	ident	"@(#)lcDBUnicode.c	1.7 01/07/16 SMI"

/*

 *

 * Copyright IBM Corporation 1993

 *

 * All Rights Reserved

 *

 * License to use, copy, modify, and distribute this software and its

 * documentation for any purpose and without fee is hereby granted,

 * 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 IBM not be

 * used in advertising or publicity pertaining to distribution of the

 * software without specific, written prior permission.

 *

 * IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS, AND 

 * NONINFRINGEMENT OF THIRD PARTY RIGHTS, IN NO EVENT SHALL

 * IBM 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.

 *

*/

#ifndef	NOT_X_ENV

#include <X11/Xlib.h>

#include <X11/Xresource.h>

#include <X11/Xlibint.h>

#include <X11/XlcPubI.h>

#else	/* NOT_X_ENV */

#define	Xmalloc	malloc

#define	Xrealloc	realloc

#define	Xfree	free

#endif	/* NOT_X_ENV */

/* specifying NOT_X_ENV allows users to just use

   the database parsing routine. */

#ifndef	BUFSIZE

#define	BUFSIZE	2048

#endif

#include <X11/Xlocale.h>

#define WC_TO_CS_CONV_TABLE_ENTRY	"wc_conversion_table"

#define CS_TO_WC_CONV_FILE_ENTRY	"cs_conversion_file"

#define CS_TO_WC_CONV_TABLE_ENTRY	"cs_conversion_table"

#define	XLOCALE_USER_DIR	".Xlocale"

#define	XLOCALE_USER_NAME	"required.charsets"

#define	XLOCALE_USER_CATEGORY	"XLC_XLOCALE_USER"

#include <stdio.h>

#include <unistd.h>

typedef struct _DatabaseRec {

    char *category;

    char *name;

    char **value;

    int value_num;

    struct _DatabaseRec *next;

} DatabaseRec, *Database;

typedef enum {

    S_NULL,	/* outside category */

    S_CATEGORY,	/* inside category */

    S_NAME,	/* has name, expecting values */

    S_VALUE

} ParseState;

typedef enum {

    T_NEWLINE,

    T_COMMENT,

    T_SEMICOLON,

    T_DOUBLE_QUOTE,

    T_LEFT_BRACE,

    T_RIGHT_BRACE,

    T_SPACE,

    T_TAB,

    T_BACKSLASH,

    T_NUMERIC_HEX,

    T_NUMERIC_DEC,

    T_NUMERIC_OCT,

    T_DEFAULT

} Token;

typedef struct {

    Token token;	/* token id */

    char *name;		/* token sequence */

    int len;		/* length of token sequence */

    int (*parse_proc)(); /* parsing procedure */

} TokenTable;

static int f_newline();

static int f_comment();

static int f_semicolon();

static int f_double_quote();

static int f_left_brace();

static int f_right_brace();

static int f_white();

static int f_backslash();

static int f_numeric();

static int f_default();

static TokenTable token_tbl[] = {

    { T_NEWLINE,	"\n",	1,	f_newline },

    { T_COMMENT,	"#",	1,	f_comment },

    { T_SEMICOLON,	";",	1,	f_semicolon },

    { T_DOUBLE_QUOTE,	"\"",	1,	f_double_quote },

    { T_LEFT_BRACE,	"{",	1,	f_left_brace },

    { T_RIGHT_BRACE,	"}",	1,	f_right_brace },

    { T_SPACE,		" ",	1,	f_white },

    { T_TAB,		"\t",	1,	f_white },

    { T_BACKSLASH,	"\\",	1,	f_backslash },

    { T_NUMERIC_HEX,	"\\x",	2,	f_numeric },

    { T_NUMERIC_DEC,	"\\d",	2,	f_numeric },

    { T_NUMERIC_OCT,	"\\o",	2,	f_numeric },

    { T_DEFAULT,	" ",	1,	f_default },	/* any character */

    0 

};

#define	SYM_NEWLINE	'\n'

#define	SYM_COMMENT	'#'

#define	SYM_SEMICOLON	';'

#define	SYM_DOUBLE_QUOTE	'"'

#define	SYM_LEFT_BRACE	'{'

#define	SYM_RIGHT_BRACE	'}'

#define	SYM_SPACE	' '

#define	SYM_TAB		'\t'

#define	SYM_BACKSLASH	'\\'

/************************************************************************/

#define MAX_NAME_NEST	64

typedef struct {

    ParseState pre_state;

    char *category;

    char *name[MAX_NAME_NEST];

    int nest_depth;

    char **value;

    int value_len;

    int value_num;

    char buf[BUFSIZE];

    int bufsize;

} DBParseInfo;

static DBParseInfo parse_info;

static void

clear_parse_info()

{

    int i;

    parse_info.pre_state = S_NULL;

    if(parse_info.category != NULL){

	Xfree(parse_info.category);

    }

    for(i = 0; i <= parse_info.nest_depth; ++i){

	if(parse_info.name[i]){

	    Xfree(parse_info.name[i]);

	}

    }

    if(parse_info.value){

	if(*parse_info.value){

	    Xfree(*parse_info.value);

	}

	Xfree((char *)parse_info.value);

    }

    memset((void *)&parse_info, 0, sizeof(DBParseInfo));

}

/************************************************************************/

typedef struct _Line {

    char *str;

    int cursize;

    int maxsize;

    int seq;

} Line;

static void

free_line(line)

    Line *line;

{

    if(line->str != NULL){

	Xfree(line->str);

    }

    memset((void *)line, 0, sizeof(Line));

}

static int

realloc_line(line, size)

    Line *line;

    int size;

{

    char *str = line->str;

    if(str != NULL){

	str = (char *)Xrealloc(str, size);

    }else{

	str = (char *)Xmalloc(size);

    }

    if(str == NULL){

	/* malloc error */

	memset((void *)line, 0, sizeof(Line));

	return 0;

    }

    line->str = str;

    line->maxsize = size;

    return 1;

}

#define	ISWHITE(ch)	((ch) == SYM_SPACE   || (ch) == SYM_TAB)

static void

zap_comment(str, quoted)

    char *str;

    int *quoted;

{

    char *p = str;

#ifdef	never

    *quoted = 0;

    if(*p == SYM_COMMENT){

	int len = strlen(str);

	if(p[len - 1] == SYM_NEWLINE){

	    *p++ = SYM_NEWLINE;

	}

	*p = '\0';

    }

#else

    while(*p){

	if(*p == SYM_DOUBLE_QUOTE){

	    if(p == str || p[-1] != SYM_BACKSLASH){

		/* unescaped double quote changes quoted state. */

		*quoted = *quoted ? 0 : 1;

	    }

	}

	if(*p == SYM_COMMENT && !*quoted){

	    int pos = p - str;

	    if(pos == 0 ||

	       ISWHITE(p[-1]) && (pos == 1 || p[-2] != SYM_BACKSLASH)){

		int len = strlen(p);

		if(len > 0 && p[len - 1] == SYM_NEWLINE){

		    /* newline is the identifier for finding end of value.

		       therefore, it should not be removed. */

		    *p++ = SYM_NEWLINE;

		}

		*p = '\0';

		break;

	    }

	}

	++p;

    }

#endif

}

static int

read_line(fd, line)

    FILE *fd;

    Line *line;

{

    char buf[BUFSIZE], *p;

    int len;

    int quoted = 0;	/* quoted by double quote? */

    char *str;

    int cur;

    str = line->str;

    cur = line->cursize = 0;

    while((p = fgets(buf, BUFSIZE, fd)) != NULL){

	++line->seq;

	zap_comment(p, &quoted);	/* remove comment line */

	len = strlen(p);

	if(len == 0){

	    if(cur > 0){

		break;

	    }

	    continue;

	}

	if(cur + len + 1 > line->maxsize){

	    /* need to reallocate buffer. */

	    if(! realloc_line(line, line->maxsize + BUFSIZE)){

		goto err;	/* realloc error. */

	    }

	    str = line->str;

	}

	strncpy(str + cur, p, len);

	cur += len;

	str[cur] = '\0';

	if(!quoted){

	    if(cur > 1 && str[cur - 2] == SYM_BACKSLASH &&

	       str[cur - 1] == SYM_NEWLINE){

		/* the line is ended backslash followed by newline.

		   need to concatinate the next line. */

		cur -= 2;

		str[cur] = '\0';

	    }else{

		break;

	    }

	}

    }

    if(quoted){

	/* error.  still in quoted state. */

	goto err;

    }

    return line->cursize = cur;

err:

    return -1;

}

/************************************************************************/

static Token

get_token(str)

    char *str;

{

    switch(*str){

    case SYM_NEWLINE:	return T_NEWLINE;

    case SYM_COMMENT:	return T_COMMENT;

    case SYM_SEMICOLON:	return T_SEMICOLON;

    case SYM_DOUBLE_QUOTE:	return T_DOUBLE_QUOTE;

    case SYM_LEFT_BRACE:	return T_LEFT_BRACE;

    case SYM_RIGHT_BRACE:	return T_RIGHT_BRACE;

    case SYM_SPACE:	return T_SPACE;

    case SYM_TAB:	return T_TAB;

    case SYM_BACKSLASH:

	switch(str[1]){

	case 'x': return T_NUMERIC_HEX;

	case 'd': return T_NUMERIC_DEC;

	case 'o': return T_NUMERIC_OCT;

	}

	return T_BACKSLASH;

    default:

	return T_DEFAULT;

    }

}

static int

get_word(str, word)

    char *str;

    char *word;

{

    char *p = str, *w = word;

    Token token;

    int token_len;

    while(*p != '\0'){

	token = get_token(p);

	token_len = token_tbl[token].len;

	if(token == T_BACKSLASH){

	    p += token_len;

	    if(*p == '\0'){

		break;

	    }

	    token = get_token(p);

	    token_len = token_tbl[token].len;

	}else if(token != T_COMMENT &&

		 token != T_DEFAULT){

	    break;

	}

	strncpy(w, p, token_len);

	p += token_len; w += token_len;

    }

    *w = '\0';

    return p - str;	/* return number of scanned chars */

}

static int

get_quoted_word(str, word)

    char *str;

    char *word;

{

    char *p = str, *w = word;

    Token token;

    int token_len;

    if(*p == SYM_DOUBLE_QUOTE){

	++p;

    }

    while(*p != '\0'){

	token = get_token(p);

	token_len = token_tbl[token].len;

	if(token == T_DOUBLE_QUOTE){

	    p += token_len;

	    goto found;

	}

	if(token == T_BACKSLASH){

	    p += token_len;

	    if(*p == '\0'){

		break;

	    }

	    token = get_token(p);

	    token_len = token_tbl[token].len;

	}

	strncpy(w, p, token_len);

	p += token_len; w += token_len;

    }

    /* error. cannot detect next double quote */

    return 0;

 found:;

    *w = '\0';

    return p - str;

}

/************************************************************************/

static int

append_value_list()

{

    char **value_list = parse_info.value;

    char *value;

    int value_num = parse_info.value_num;

    int value_len = parse_info.value_len;

    char *str = parse_info.buf;

    int len = parse_info.bufsize;

    char *p;

    if(len < 1){

	return 1; /* return with no error */

    }

    if(value_list == (char **)NULL){

	value_list = (char **)Xmalloc(sizeof(char *) * 2);

	*value_list = NULL;

    }else{

	value_list = (char **)

	    Xrealloc(value_list, sizeof(char *) * (value_num + 2));

    }

    if(value_list == (char **)NULL){

	goto err;

    }

    value = *value_list;

    if(value == NULL){

	value = (char *)Xmalloc(value_len + len + 1);

    }else{

	value = (char *)Xrealloc(value, value_len + len + 1);

    }

    if(value == NULL){

	goto err;

    }

    if(value != *value_list){

	int delta, i;

	delta = value - *value_list;

	*value_list = value;

	for(i = 1; i < value_num; ++i){

	    value_list[i] += delta;

	}

    }

    value_list[value_num] = p = &value[value_len];

    value_list[value_num + 1] = NULL;

    strncpy(p, str, len);

    p[len] = 0;

    parse_info.value = value_list;

    parse_info.value_num = value_num + 1;

    parse_info.value_len = value_len + len + 1;

    parse_info.bufsize = 0;

    return 1;

err:

    if(value_list){

	Xfree((char **)value_list);

    }

    if(value){

	Xfree(value);

    }

    parse_info.value = (char **)NULL;

    parse_info.value_num = 0;

    parse_info.value_len = 0;

    parse_info.bufsize = 0;

    return 0;

}

static int 

construct_name(name)

    char *name;

{

    int i, len = 0;

    char *p = name;

    for(i = 0; i <= parse_info.nest_depth; ++i){

	len += strlen(parse_info.name[i]) + 1;

    }

    strcpy(p, parse_info.name[0]);

    p += strlen(parse_info.name[0]);

    for(i = 1; i <= parse_info.nest_depth; ++i){

	*p++ = '.';

	strcpy(p, parse_info.name[i]);

	p += strlen(parse_info.name[i]);

    }

    return *name != '\0';

}

static int

store_to_database(db)

    Database *db;

{

    Database new = (Database)NULL;

    char name[BUFSIZE];

    if(parse_info.pre_state == S_VALUE){

	if(! append_value_list()){

	    goto err;

	}

    }

    if(parse_info.name[parse_info.nest_depth] == NULL){

	goto err;

    }

    new = (Database)Xmalloc(sizeof(DatabaseRec));

    if(new == (Database)NULL){

	goto err;